import * as HttpServer from "effect/http/HttpServer";
import {
RelayClientAuth,
RelayClientPrincipal,
type RelayClientDeviceRecord,
} from "@t3tools/contracts/relay";
import * as EnvironmentLinker from "../environments/EnvironmentLinker.ts";
import * as RelayTokens from "../auth/RelayTokens.ts";
import * as Devices from "../agentActivity/Devices.ts";
// @effect-diagnostics-next-line nodeBuiltinImport:off -- Effect's Crypto has no generateKeyPairSync.
import * as NodeCrypto from "node:crypto";
import { createClerkClient, verifyToken } from "@clerk/backend";
import * as NodeHttpPlatform from "@effect/platform-node/NodeHttpPlatform";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { describe, expect, it } from "@effect/vitest";
import { vi } from "vite-plus/test";
import * as Context from "effect/Context";
import * as NodeCryptoLayer from "@effect/platform-node/NodeCrypto";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Predicate from "effect/Predicate";
import * as Redacted from "effect/Redacted";
import * as Schema from "effect/Schema";
import * as Tracer from "effect/Tracer";
import * as Etag from "effect/http/Etag";
import * as HttpEffect from "effect/http/HttpEffect";
import * as HttpRouter from "effect/http/HttpRouter";
import * as HttpServerRequest from "effect/http/HttpServerRequest";
import * as HttpServerResponse from "effect/http/HttpServerResponse";
import * as HttpApi from "effect/http-api/HttpApi";
import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
import { EnvironmentId } from "@t3tools/contracts";
import {
RelayEnvironmentAuth,
RelayEnvironmentPrincipal,
RelayApi,
RelayEnvironmentLinkUnavailableError,
RelayEnvironmentLinkRequest,
} from "@t3tools/contracts/relay";
import { relayProtectedErrorMessage } from "@t3tools/client-runtime/relay";
import { RELAY_MANAGED_TUNNEL_RECOVERY_TYP, signRelayJwt } from "@t3tools/shared/relayJwt";
import {
RELAY_HTTP_ROUTER_CONFIG,
recoverEnvironmentTunnelRecord,
registerEnvironmentTunnelRecovery,
relayDpopFailureReason,
traceRelayHttpRequestWith,
unlinkEnvironmentRecord,
verifyRelayClientBearerToken,
verifyEnvironmentTunnelRecoveryProof,
withoutCapturedParentSpan,
} from "./Api.ts";
import * as RelayHttpApi from "./Api.ts";
import * as RelayConfiguration from "../Config.ts";
import * as RelayDb from "../db.ts";
import * as EnvironmentCredentials from "../environments/EnvironmentCredentials.ts";
import * as HeldHooks from "../hooks/HeldHooks.ts";
import * as HookInbox from "../hooks/HookInbox.ts";
import * as EnvironmentLinks from "../environments/EnvironmentLinks.ts";
import * as ManagedEndpointAllocations from "../environments/ManagedEndpointAllocations.ts";
import * as ManagedEndpointProvider from "../environments/ManagedEndpointProvider.ts";
import * as ManagedTunnelLimits from "../environments/ManagedTunnelLimits.ts";
import * as AgentActivityPublisher from "../agentActivity/AgentActivityPublisher.ts";
import * as EnvironmentPublishSignatures from "../environments/EnvironmentPublishSignatures.ts";
import * as T3ChatAccounts from "../t3chat/T3ChatAccounts.ts";
vi.mock("@clerk/backend", () => ({
createClerkClient: vi.fn(),
verifyToken: vi.fn(),
}));
const relaySettings: RelayConfiguration.RelayConfiguration["Service"] = {
relayIssuer: "https://relay.example.test",
apns: {
teamId: "apns-team",
keyId: "apns-key",
privateKey: Redacted.make("apns-private-key"),
bundleId: "com.example.t3",
environment: "sandbox",
},
clerkSecretKey: Redacted.make("clerk-secret-key"),
clerkPublishableKey: "pk_test_test",
clerkJwtAudience: "t3-code-relay",
apnsDeliveryJobSigningSecret: Redacted.make("apns-delivery-secret"),
cloudMintPrivateKey: Redacted.make("cloud-mint-private-key"),
cloudMintPublicKey: "cloud-mint-public-key",
managedEndpointBaseDomain: undefined,
managedEndpointNamespace: undefined,
};
const encodeLinkRequest = Schema.encodeEffect(Schema.fromJsonString(RelayEnvironmentLinkRequest));
const decodeLinkUnavailableError = Schema.decodeUnknownEffect(RelayEnvironmentLinkUnavailableError);
describe("managed endpoint provisioning errors", () => {
it.effect("returns the failed stage without exposing provider secrets through HTTP", () => {
let traceId = "";
const handlers = RelayHttpApi.layerClientApi.pipe(
HttpRouter.provideRequest(
Layer.mergeAll(
Layer.mock(EnvironmentCredentials.EnvironmentCredentials, {}),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(RelayDb.RelayTransactions, {}),
Layer.mock(HookInbox.HookInbox, {}),
),
),
Layer.provide(
Layer.mergeAll(
Layer.succeed(RelayConfiguration.RelayConfiguration, relaySettings),
NodeCryptoLayer.layer,
Layer.mock(RelayTokens.RelayTokens, { resolveDpopAccessTokenScopes: () => null }),
Layer.mock(EnvironmentLinker.EnvironmentLinker, {
link: () =>
Effect.gen(function* () {
traceId = (yield* Effect.currentSpan.pipe(Effect.orDie)).traceId;
return yield* new ManagedEndpointProvider.ManagedEndpointProvisioningFailed({
userId: "user-1",
environmentId: "environment-1",
stage: "ensure-tunnel",
tunnelId: "private-tunnel-id",
cause: new Error("private-provider-token"),
});
}),
}),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(Devices.Devices, {}),
Layer.mock(T3ChatAccounts.T3ChatAccounts, { available: false }),
Layer.mock(ManagedTunnelLimits.ManagedTunnelLimits, {}),
),
),
Layer.provideMerge(
Layer.succeed(RelayClientAuth, {
clientBearer: (effect) =>
Effect.provideService(effect, RelayClientPrincipal, {
userId: "user-1",
token: "test-token",
}),
}),
),
);
return Effect.gen(function* () {
const app = yield* Effect.acquireRelease(
Effect.sync(() =>
HttpRouter.toWebHandler(
HttpApiBuilder.layer(HttpApi.make("RelayApi").add(RelayApi.groups.client)).pipe(
Layer.provide(handlers),
Layer.provide(HttpServer.layerServices),
),
{ disableLogger: true },
),
),
(app) => Effect.promise(() => app.dispose()),
);
const payload = yield* encodeLinkRequest({
proof: "test-proof",
notificationsEnabled: false,
liveActivitiesEnabled: false,
managedTunnelsEnabled: true,
});
const response = yield* Effect.promise(() =>
app.handler(
new Request("https://relay.example.test/v1/client/environment-links", {
method: "POST",
headers: {
authorization: "Bearer test-token",
"content-type": "application/json",
},
body: payload,
}),
),
);
expect(response.status).toBe(503);
const body = yield* Effect.promise(() => response.json());
expect(body).toEqual({
_tag: "RelayEnvironmentLinkUnavailableError",
code: "environment_link_unavailable",
reason: "managed_endpoint_provisioning_failed",
provisioningStage: "ensure-tunnel",
traceId,
});
const error = yield* decodeLinkUnavailableError(body);
expect(relayProtectedErrorMessage(error)).toBe(
"Relay cannot provision the managed endpoint (managed_endpoint_provisioning_failed). Failed stage: ensure-tunnel.",
);
}).pipe(Effect.scoped);
});
});
describe("device listing compatibility", () => {
it.effect("keeps v1 iOS-only while v2 returns every platform for the same account", () => {
const iphone: RelayClientDeviceRecord = {
deviceId: "iphone",
label: "iPhone",
platform: "ios",
iosMajorVersion: 18,
appVersion: "1.0.0",
notifications: {
enabled: true,
notifyOnApproval: true,
notifyOnInput: true,
notifyOnCompletion: true,
notifyOnFailure: true,
},
liveActivities: { enabled: true },
updatedAt: "2026-09-09T00:00:00.000Z",
};
const android: RelayClientDeviceRecord = {
...iphone,
deviceId: "android",
label: "Android",
platform: "android",
iosMajorVersion: null,
androidApiLevel: 36,
};
const layerHandlers = RelayHttpApi.layerClientApi.pipe(
HttpRouter.provideRequest(
Layer.mergeAll(
Layer.mock(EnvironmentCredentials.EnvironmentCredentials, {}),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(RelayDb.RelayTransactions, {}),
Layer.mock(HookInbox.HookInbox, {}),
),
),
Layer.provide(
Layer.mergeAll(
Layer.succeed(RelayConfiguration.RelayConfiguration, relaySettings),
NodeCryptoLayer.layer,
Layer.mock(RelayTokens.RelayTokens, { resolveDpopAccessTokenScopes: () => null }),
Layer.mock(EnvironmentLinker.EnvironmentLinker, {}),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(Devices.Devices, {
listForUser: ({ userId }) => {
expect(userId).toBe("user-1");
return Effect.succeed([iphone, android]);
},
}),
Layer.mock(T3ChatAccounts.T3ChatAccounts, { available: false }),
Layer.mock(ManagedTunnelLimits.ManagedTunnelLimits, {}),
),
),
Layer.provideMerge(
Layer.succeed(RelayClientAuth, {
clientBearer: (effect) =>
Effect.provideService(effect, RelayClientPrincipal, {
userId: "user-1",
token: "test-token",
}),
}),
),
);
return Effect.gen(function* () {
const app = yield* Effect.acquireRelease(
Effect.sync(() =>
HttpRouter.toWebHandler(
HttpApiBuilder.layer(HttpApi.make("RelayApi").add(RelayApi.groups.client)).pipe(
Layer.provide(layerHandlers),
Layer.provide(HttpServer.layerServices),
),
{ disableLogger: true },
),
),
(app) => Effect.promise(() => app.dispose()),
);
for (const [version, devices] of [
["v1", [iphone]],
["v2", [iphone, android]],
] as const) {
const response = yield* Effect.promise(() =>
app.handler(
new Request(`https://relay.example.test/${version}/client/devices`, {
headers: { authorization: "Bearer test-token" },
}),
),
);
expect(response.status).toBe(200);
expect(response.headers.get("cache-control")).toBe("no-store");
expect(yield* Effect.promise(() => response.json())).toEqual({ devices });
}
}).pipe(Effect.scoped);
});
});
describe("Cloudflare rate-limit retry hint", () => {
const provisioningFailed = (cause?: unknown) =>
new ManagedEndpointProvider.ManagedEndpointProvisioningFailed({
userId: "user-1",
environmentId: "env-1",
stage: "ensure-tunnel",
...(cause === undefined
? {}
: {
cause: new ManagedEndpointProvider.ManagedEndpointTunnelClientError({
operation: "list",
cause,
}),
}),
});
const linkResponse = (failure: ManagedEndpointProvider.ManagedEndpointProvisioningFailed) => {
const layerHandlers = RelayHttpApi.layerClientApi.pipe(
HttpRouter.provideRequest(
Layer.mergeAll(
Layer.mock(EnvironmentCredentials.EnvironmentCredentials, {}),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(RelayDb.RelayTransactions, {}),
Layer.mock(HookInbox.HookInbox, {}),
),
),
Layer.provide(
Layer.mergeAll(
Layer.succeed(RelayConfiguration.RelayConfiguration, relaySettings),
NodeCryptoLayer.layer,
Layer.mock(RelayTokens.RelayTokens, { resolveDpopAccessTokenScopes: () => null }),
Layer.mock(EnvironmentLinker.EnvironmentLinker, { link: () => Effect.fail(failure) }),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(Devices.Devices, {}),
Layer.mock(T3ChatAccounts.T3ChatAccounts, { available: false }),
Layer.mock(ManagedTunnelLimits.ManagedTunnelLimits, {}),
),
),
Layer.provideMerge(
Layer.succeed(RelayClientAuth, {
clientBearer: (effect) =>
Effect.provideService(effect, RelayClientPrincipal, {
userId: "user-1",
token: "test-token",
}),
}),
),
);
return Effect.acquireRelease(
Effect.sync(() =>
HttpRouter.toWebHandler(
HttpApiBuilder.layer(HttpApi.make("RelayApi").add(RelayApi.groups.client)).pipe(
Layer.provide(layerHandlers),
Layer.provide(HttpServer.layerServices),
),
{ disableLogger: true },
),
),
(app) => Effect.promise(() => app.dispose()),
).pipe(
Effect.flatMap((app) =>
Effect.promise(() =>
app.handler(
new Request("https://relay.example.test/v1/client/environment-links", {
method: "POST",
headers: { authorization: "Bearer test-token", "content-type": "application/json" },
body: JSON.stringify({
proof: "signed-proof",
notificationsEnabled: true,
liveActivitiesEnabled: true,
managedTunnelsEnabled: true,
}),
}),
),
),
),
);
};
it.effect("tells a link refused during a Cloudflare pause when to retry", () =>
Effect.gen(function* () {
const paused = yield* linkResponse(
provisioningFailed(
new ManagedEndpointProvider.CloudflareApiPaused({ retryAfterMillis: 24_100 }),
),
);
expect(paused.status).toBe(503);
expect(paused.headers.get("retry-after")).toBe("25");
const other = yield* linkResponse(provisioningFailed());
expect(other.status).toBe(503);
expect(other.headers.get("retry-after")).toBeNull();
}).pipe(Effect.scoped),
);
});
describe("relay client authentication", () => {
it.effect("preserves the existing Clerk session JWT path", () =>
Effect.gen(function* () {
vi.mocked(verifyToken).mockResolvedValue({
sub: "user_session",
aud: relaySettings.clerkJwtAudience,
} as never);
expect(yield* verifyRelayClientBearerToken(relaySettings, "session-token")).toEqual({
sub: "user_session",
mode: "clerk_session_bearer",
});
expect(verifyToken).toHaveBeenCalledWith("session-token", {
secretKey: "clerk-secret-key",
audience: relaySettings.clerkJwtAudience,
});
expect(createClerkClient).not.toHaveBeenCalled();
}).pipe(
Effect.ensuring(
Effect.sync(() => {
vi.mocked(verifyToken).mockReset();
vi.mocked(createClerkClient).mockReset();
}),
),
),
);
it.effect("falls back to Clerk OAuth token verification for the headless CLI", () =>
Effect.gen(function* () {
vi.mocked(verifyToken).mockRejectedValue(new Error("not a session JWT"));
vi.mocked(createClerkClient).mockReturnValue({
authenticateRequest: vi.fn().mockResolvedValue({
isAuthenticated: true,
toAuth: () => ({ userId: "user_oauth" }),
}),
} as never);
expect(yield* verifyRelayClientBearerToken(relaySettings, "oauth-token")).toEqual({
sub: "user_oauth",
mode: "clerk_oauth_bearer",
});
expect(createClerkClient).toHaveBeenCalledWith({
secretKey: "clerk-secret-key",
publishableKey: "pk_test_test",
});
}).pipe(
Effect.ensuring(
Effect.sync(() => {
vi.mocked(verifyToken).mockReset();
vi.mocked(createClerkClient).mockReset();
}),
),
),
);
});
describe("relay DPoP failure mapping", () => {
it("maps verifier failures to safe client-facing categories", () => {
const mappings = [
["time_window", "time_window"],
["key_mismatch", "key_mismatch"],
["method_mismatch", "request_mismatch"],
["url_mismatch", "request_mismatch"],
["access_token_hash_mismatch", "token_mismatch"],
["replayed", "replay"],
["missing_proof", "invalid_proof"],
["malformed_proof", "invalid_proof"],
["invalid_signature", "invalid_proof"],
["invalid_proof", "invalid_proof"],
] as const;
for (const [code, expected] of mappings) {
expect(relayDpopFailureReason(code)).toBe(expected);
}
});
});
describe("relay environment authentication", () => {
it.effect("preserves credential lookup persistence failures as internal errors", () => {
const failure = new EnvironmentCredentials.EnvironmentCredentialAuthenticatePersistenceError({
stage: "lookup-credential",
cause: "database unavailable",
});
const credentials: EnvironmentCredentials.EnvironmentCredentials["Service"] = {
create: () => Effect.die("unused create"),
authenticate: () => Effect.fail(failure),
revokeForEnvironmentPublicKey: () => Effect.die("unused revoke"),
};
return Effect.gen(function* () {
const auth = yield* RelayEnvironmentAuth;
const error = yield* Effect.flip(
auth.environmentBearer(Effect.succeed(HttpServerResponse.empty()), {
credential: Redacted.make("environment-credential"),
endpoint: {} as never,
group: {} as never,
}),
);
expect(Predicate.isTagged(error, "RelayInternalError")).toBe(true);
if (Predicate.isTagged(error, "RelayInternalError")) {
expect(error.reason).toBe("persistence_failed");
}
}).pipe(
Effect.provideService(
HttpServerRequest.HttpServerRequest,
HttpServerRequest.fromWeb(new Request("https://relay.test/v1/server/link")),
),
Effect.provideService(HttpServerRequest.ParsedSearchParams, {}),
Effect.provideService(HttpRouter.RouteContext, {
params: {},
route: {} as never,
}),
Effect.provide(
RelayHttpApi.layerEnvironmentAuth.pipe(
Layer.provide(Layer.succeed(EnvironmentCredentials.EnvironmentCredentials, credentials)),
),
),
Effect.scoped,
);
});
});
function layerRelayUnlinkTest(input?: {
readonly withTransaction?: RelayDb.RelayTransactions["Service"]["withTransaction"];
readonly getForUser?: EnvironmentLinks.EnvironmentLinks["Service"]["getForUser"];
readonly revokeForUser?: EnvironmentLinks.EnvironmentLinks["Service"]["revokeForUser"];
readonly revokeCredential?: EnvironmentCredentials.EnvironmentCredentials["Service"]["revokeForEnvironmentPublicKey"];
readonly prepareDeprovision?: ManagedEndpointProvider.ManagedEndpointProvider["Service"]["prepareDeprovision"];
readonly deprovision?: ManagedEndpointProvider.ManagedEndpointProvider["Service"]["deprovision"];
readonly provision?: ManagedEndpointProvider.ManagedEndpointProvider["Service"]["provision"];
readonly reconcileOrigin?: ManagedEndpointProvider.ManagedEndpointProvider["Service"]["reconcileOrigin"];
readonly release?: ManagedEndpointProvider.ManagedEndpointProvider["Service"]["release"];
readonly clearInbox?: HookInbox.HookInbox["Service"]["clear"];
}) {
return Layer.mergeAll(
Layer.mock(HookInbox.HookInbox, {
clear: input?.clearInbox ?? (() => Effect.void),
}),
Layer.succeed(
RelayDb.RelayTransactions,
RelayDb.RelayTransactions.of({
withTransaction: input?.withTransaction ?? ((effect) => effect),
}),
),
Layer.succeed(
EnvironmentLinks.EnvironmentLinks,
EnvironmentLinks.EnvironmentLinks.of({
upsert: () => Effect.die("unused upsert"),
listDeliveryUsersForEnvironment: () => Effect.die("unused listDeliveryUsersForEnvironment"),
listForUser: () => Effect.die("unused listForUser"),
getForUser: input?.getForUser ?? (() => Effect.succeed(null)),
findActiveManagedForEnvironment: () => Effect.die("unused findActiveManagedForEnvironment"),
setHoldWebhooksWhileOffline: () => Effect.die("unused setHoldWebhooksWhileOffline"),
revokeForUser: input?.revokeForUser ?? (() => Effect.succeed(false)),
}),
),
Layer.succeed(
EnvironmentCredentials.EnvironmentCredentials,
EnvironmentCredentials.EnvironmentCredentials.of({
create: () => Effect.die("unused create"),
authenticate: () => Effect.die("unused authenticate"),
revokeForEnvironmentPublicKey: input?.revokeCredential ?? (() => Effect.succeed(false)),
}),
),
Layer.succeed(
ManagedEndpointProvider.ManagedEndpointProvider,
ManagedEndpointProvider.ManagedEndpointProvider.of({
provision: input?.provision ?? (() => Effect.die("unused provision")),
reconcileOrigin: input?.reconcileOrigin ?? (() => Effect.succeed("ready")),
prepareDeprovision: input?.prepareDeprovision ?? (() => Effect.succeed(null)),
deprovision: input?.deprovision ?? (() => Effect.succeed(true)),
release: input?.release ?? (() => Effect.die("unused release")),
}),
),
);
}
const linkedEnvironmentRecord = {
environmentId: EnvironmentId.make("environment-1"),
label: "Environment 1",
endpoint: {
httpBaseUrl: "https://environment-1.example.test/",
wsBaseUrl: "wss://environment-1.example.test/ws",
providerKind: "cloudflare_tunnel",
},
environmentPublicKey: "public-key",
linkedAt: "2026-07-28T00:00:00.000Z",
} as const;
describe("relay managed tunnel recovery", () => {
it.effect("binds recovery requests to the host, cloud user, and T3 service origin", () =>
Effect.gen(function* () {
const keyPair = NodeCrypto.generateKeyPairSync("ed25519", {
privateKeyEncoding: { format: "pem", type: "pkcs8" },
publicKeyEncoding: { format: "pem", type: "spki" },
});
const now = yield* DateTime.now;
const issuedAt = Math.floor(now.epochMilliseconds / 1_000);
const proof = yield* signRelayJwt({
privateKey: keyPair.privateKey,
typ: RELAY_MANAGED_TUNNEL_RECOVERY_TYP,
payload: {
iss: "t3-env:environment-1",
aud: "https://relay.example.test",
sub: "environment-1",
jti: "recovery-proof",
iat: issuedAt,
exp: issuedAt + 60,
action: "recover",
environmentId: "environment-1",
cloudUserId: "user-1",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
},
});
const request = {
action: "recover" as const,
proof,
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: keyPair.publicKey,
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
};
yield* verifyEnvironmentTunnelRecoveryProof(request);
const wrongOwner = yield* Effect.flip(
verifyEnvironmentTunnelRecoveryProof({ ...request, userId: "user-2" }),
);
expect(wrongOwner).toMatchObject({ _tag: "Unauthorized" });
const wrongOrigin = yield* Effect.flip(
verifyEnvironmentTunnelRecoveryProof({
...request,
origin: { localHttpHost: "127.0.0.1", localHttpPort: 5432 },
}),
);
expect(wrongOrigin).toMatchObject({ _tag: "Unauthorized" });
const wrongAction = yield* Effect.flip(
verifyEnvironmentTunnelRecoveryProof({
action: "register",
proof,
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: keyPair.publicKey,
tunnelId: "existing-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(wrongAction).toMatchObject({ _tag: "Unauthorized" });
}).pipe(
Effect.provideService(RelayConfiguration.RelayConfiguration, relaySettings),
Effect.provide(NodeCryptoLayer.layerSignature),
),
);
it.effect("rejects a signed registration proof for a different origin", () =>
Effect.gen(function* () {
const keyPair = NodeCrypto.generateKeyPairSync("ed25519", {
privateKeyEncoding: { format: "pem", type: "pkcs8" },
publicKeyEncoding: { format: "pem", type: "spki" },
});
const now = yield* DateTime.now;
const issuedAt = Math.floor(now.epochMilliseconds / 1_000);
const proof = yield* signRelayJwt({
privateKey: keyPair.privateKey,
typ: RELAY_MANAGED_TUNNEL_RECOVERY_TYP,
payload: {
iss: "t3-env:environment-1",
aud: "https://relay.example.test",
sub: "environment-1",
jti: "registration-origin-proof",
iat: issuedAt,
exp: issuedAt + 60,
action: "register",
environmentId: "environment-1",
cloudUserId: "user-1",
tunnelId: "existing-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
},
});
const error = yield* Effect.flip(
verifyEnvironmentTunnelRecoveryProof({
action: "register",
proof,
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: keyPair.publicKey,
tunnelId: "existing-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 5432 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
}).pipe(
Effect.provideService(RelayConfiguration.RelayConfiguration, relaySettings),
Effect.provide(NodeCryptoLayer.layerSignature),
),
);
it.effect("registers recovery for an existing tunnel without provisioning it", () => {
let recoveryEnabledFor: {
readonly userId: string;
readonly environmentId: string;
readonly tunnelId: string;
readonly environmentPublicKey: string;
readonly origin: { readonly localHttpHost: string; readonly localHttpPort: number };
} | null = null;
return Effect.gen(function* () {
expect(
yield* registerEnvironmentTunnelRecovery({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
tunnelId: "existing-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
).toEqual({ status: "ready" });
expect(recoveryEnabledFor).toEqual({
userId: "user-1",
environmentId: "environment-1",
tunnelId: "existing-tunnel",
environmentPublicKey: "public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
});
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
provision: () => Effect.die("registration must not provision a tunnel"),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: (input) =>
Effect.sync(() => {
recoveryEnabledFor = input;
return true;
}),
}),
),
),
);
});
it.effect("requests recovery without enabling a stale tunnel", () => {
let recoveryEnabled = false;
return Effect.gen(function* () {
expect(
yield* registerEnvironmentTunnelRecovery({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
tunnelId: "deleted-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
).toEqual({ status: "recovery_required" });
expect(recoveryEnabled).toBe(false);
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
reconcileOrigin: () => Effect.succeed("recovery_required"),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () =>
Effect.sync(() => {
recoveryEnabled = true;
return true;
}),
}),
),
),
);
});
it.effect("rejects recovery registration for a different environment key", () => {
let recoveryEnabled = false;
return Effect.gen(function* () {
const error = yield* Effect.flip(
registerEnvironmentTunnelRecovery({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "different-public-key",
tunnelId: "existing-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
expect(recoveryEnabled).toBe(false);
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () =>
Effect.sync(() => {
recoveryEnabled = true;
return true;
}),
}),
),
),
);
});
it.effect("rejects recovery registration when the recorded tunnel changed", () =>
Effect.gen(function* () {
const error = yield* Effect.flip(
registerEnvironmentTunnelRecovery({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
tunnelId: "stale-tunnel",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () => Effect.succeed(false),
}),
),
),
),
);
it.effect("recovers a linked environment and marks its tunnel as recoverable", () => {
let recoveryEnabledFor: {
readonly userId: string;
readonly environmentId: string;
readonly tunnelId: string;
readonly environmentPublicKey: string;
} | null = null;
const runtime = {
providerKind: "cloudflare_tunnel" as const,
connectorToken: "replacement-token",
tunnelId: "replacement-tunnel",
};
return Effect.gen(function* () {
expect(
yield* recoverEnvironmentTunnelRecord({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
).toEqual({
endpoint: linkedEnvironmentRecord.endpoint,
endpointRuntime: runtime,
});
expect(recoveryEnabledFor).toEqual({
userId: "user-1",
environmentId: "environment-1",
tunnelId: "replacement-tunnel",
environmentPublicKey: "public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
});
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
provision: () =>
Effect.succeed({
endpoint: linkedEnvironmentRecord.endpoint,
runtime,
}),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: (input) =>
Effect.sync(() => {
recoveryEnabledFor = input;
return true;
}),
}),
),
),
);
});
it.effect("rejects a credential from a different environment owner", () => {
let provisioned = false;
return Effect.gen(function* () {
const error = yield* Effect.flip(
recoverEnvironmentTunnelRecord({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "different-public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
expect(provisioned).toBe(false);
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
provision: () =>
Effect.sync(() => {
provisioned = true;
return {
endpoint: linkedEnvironmentRecord.endpoint,
runtime: { providerKind: "cloudflare_tunnel", connectorToken: "token" },
};
}),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () => Effect.die("unused"),
}),
),
),
);
});
it.effect("does not recover a publish-only environment", () =>
Effect.gen(function* () {
const error = yield* Effect.flip(
recoverEnvironmentTunnelRecord({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () =>
Effect.succeed({
...linkedEnvironmentRecord,
endpoint: {
...linkedEnvironmentRecord.endpoint,
providerKind: "manual" as const,
},
}),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () => Effect.die("unused"),
}),
),
),
),
);
it.effect("rejects a recovered tunnel that changes the linked endpoint", () => {
let recoveryEnabled = false;
const cleaned: Array<string> = [];
return Effect.gen(function* () {
const error = yield* Effect.flip(
recoverEnvironmentTunnelRecord({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
expect(recoveryEnabled).toBe(false);
expect(cleaned).toEqual(["replacement-tunnel"]);
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
provision: () =>
Effect.succeed({
endpoint: {
httpBaseUrl: "https://different.example.test/",
wsBaseUrl: "wss://different.example.test/ws",
providerKind: "cloudflare_tunnel",
},
runtime: {
providerKind: "cloudflare_tunnel",
connectorToken: "token",
tunnelId: "replacement-tunnel",
},
}),
prepareDeprovision: () => Effect.die("must keep the active allocation"),
deprovision: () => Effect.die("must keep the active link DNS"),
release: ({ expectedTunnelId }) =>
Effect.sync(() => {
if (expectedTunnelId) {
cleaned.push(expectedTunnelId);
}
return true;
}),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () =>
Effect.sync(() => {
recoveryEnabled = true;
return true;
}),
}),
),
),
);
});
it.effect.each([
{ state: "removed", currentLink: null },
{
state: "publish-only",
currentLink: {
...linkedEnvironmentRecord,
endpoint: {
...linkedEnvironmentRecord.endpoint,
providerKind: "manual" as const,
},
},
},
])("removes a recovered tunnel when its link becomes $state", ({ currentLink }) => {
let lookups = 0;
const cleaned: Array<string> = [];
const target = {
userId: "user-1",
environmentId: "environment-1",
hostname: "environment-1.example.test",
tunnelId: "replacement-tunnel",
tunnelName: "environment-1-tunnel",
dnsRecordId: "dns-1",
readyAt: "2026-07-28T00:00:00.000Z",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
updatedAt: "replacement-generation",
generation: 3,
tunnelReleasedAt: null,
} satisfies ManagedEndpointProvider.ManagedEndpointDeprovisionTarget;
return Effect.gen(function* () {
const error = yield* Effect.flip(
recoverEnvironmentTunnelRecord({
userId: "user-1",
environmentId: "environment-1",
environmentPublicKey: "public-key",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
}),
);
expect(error).toMatchObject({ _tag: "Unauthorized" });
expect(cleaned).toEqual(["replacement-tunnel"]);
}).pipe(
Effect.provide(
Layer.merge(
layerRelayUnlinkTest({
getForUser: () =>
Effect.sync(() => (++lookups === 1 ? linkedEnvironmentRecord : currentLink)),
provision: () =>
Effect.succeed({
endpoint: linkedEnvironmentRecord.endpoint,
runtime: {
providerKind: "cloudflare_tunnel",
connectorToken: "replacement-token",
tunnelId: "replacement-tunnel",
},
}),
prepareDeprovision: () => Effect.succeed(target),
deprovision: ({ target: captured }) =>
Effect.sync(() => {
if (captured?.tunnelId) {
cleaned.push(captured.tunnelId);
}
return true;
}),
}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations)({
enableRecovery: () => Effect.succeed(false),
}),
),
),
);
});
});
describe("relay environment unlink", () => {
it.effect("drops the unlinked endpoint's held webhooks, even if clearing fails", () => {
const cleared: Array<string> = [];
const endpointKey = "0123456789abcdef";
const unlink = (clearFails: boolean) =>
unlinkEnvironmentRecord({
userId: "user-1",
environmentId: "environment-1",
managedEndpointNamespace: "dev",
}).pipe(
Effect.provide(
layerRelayUnlinkTest({
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
revokeForUser: () => Effect.succeed(true),
prepareDeprovision: () =>
Effect.succeed({
userId: "user-1",
environmentId: "environment-1",
hostname: "dev-0123456789abcdef.example.test",
tunnelId: "tunnel-1",
tunnelName: `t3coderelay-managedendpoint-dev-${endpointKey}`,
dnsRecordId: "dns-1",
readyAt: "2026-07-28T00:00:00.000Z",
tunnelReleasedAt: null,
origin: null,
updatedAt: "2026-07-28T00:00:00.000Z",
generation: 1,
}),
clearInbox: (input) =>
clearFails
? Effect.fail(
new HookInbox.HookInboxError({
operation: "clear",
endpointKey: input.endpointKey,
cause: new Error("unavailable"),
}),
)
: Effect.sync(() => void cleared.push(input.endpointKey)),
}),
),
);
return Effect.gen(function* () {
expect(yield* unlink(false)).toBe(true);
expect(cleared).toEqual([endpointKey]);
expect(yield* unlink(true)).toBe(true);
});
});
it.effect("commits database revocation before deprovisioning the managed endpoint", () => {
const calls: Array<string> = [];
const deprovisionTarget = {
userId: "user-1",
environmentId: "environment-1",
hostname: "environment-1.example.test",
tunnelId: "tunnel-1",
tunnelName: "environment-1-tunnel",
dnsRecordId: "dns-1",
readyAt: "2026-07-28T00:00:00.000Z",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
updatedAt: "generation-before-unlink",
generation: 1,
tunnelReleasedAt: null,
} satisfies ManagedEndpointProvider.ManagedEndpointDeprovisionTarget;
return Effect.gen(function* () {
expect(
yield* unlinkEnvironmentRecord({
userId: "user-1",
environmentId: "environment-1",
}),
).toBe(true);
expect(calls).toEqual([
"prepare",
"lookup",
"transaction",
"link",
"credential",
"deprovision",
]);
}).pipe(
Effect.provide(
layerRelayUnlinkTest({
withTransaction: (effect) => {
calls.push("transaction");
return effect;
},
getForUser: () =>
Effect.sync(() => {
calls.push("lookup");
return linkedEnvironmentRecord;
}),
revokeForUser: () =>
Effect.sync(() => {
calls.push("link");
return true;
}),
revokeCredential: () =>
Effect.sync(() => {
calls.push("credential");
return true;
}),
prepareDeprovision: () =>
Effect.sync(() => {
calls.push("prepare");
return deprovisionTarget;
}),
deprovision: (request) =>
Effect.sync(() => {
expect(request.target).toBe(deprovisionTarget);
calls.push("deprovision");
return true;
}),
}),
),
);
});
it.effect("does not deprovision when database revocation fails", () => {
const calls: Array<string> = [];
const failure = new EnvironmentCredentials.EnvironmentCredentialRevokePersistenceError({
environmentId: "environment-1",
cause: "database unavailable",
});
return Effect.gen(function* () {
expect(
yield* Effect.flip(
unlinkEnvironmentRecord({
userId: "user-1",
environmentId: "environment-1",
}),
),
).toBe(failure);
expect(calls).toEqual(["prepare", "transaction", "link", "credential"]);
}).pipe(
Effect.provide(
layerRelayUnlinkTest({
withTransaction: (effect) => {
calls.push("transaction");
return effect;
},
getForUser: () => Effect.succeed(linkedEnvironmentRecord),
revokeForUser: () =>
Effect.sync(() => {
calls.push("link");
return true;
}),
revokeCredential: () =>
Effect.sync(() => {
calls.push("credential");
}).pipe(Effect.andThen(Effect.fail(failure))),
prepareDeprovision: () =>
Effect.sync(() => {
calls.push("prepare");
return null;
}),
deprovision: () =>
Effect.sync(() => {
calls.push("deprovision");
return true;
}),
}),
),
);
});
it.effect("retries deprovisioning after the link is already revoked", () => {
const calls: Array<string> = [];
return Effect.gen(function* () {
expect(
yield* unlinkEnvironmentRecord({
userId: "user-1",
environmentId: "environment-1",
}),
).toBe(false);
expect(calls).toEqual(["prepare", "deprovision"]);
}).pipe(
Effect.provide(
layerRelayUnlinkTest({
prepareDeprovision: () =>
Effect.sync(() => {
calls.push("prepare");
return null;
}),
deprovision: () =>
Effect.sync(() => {
calls.push("deprovision");
return true;
}),
}),
),
);
});
it.effect("retries unlink cleanup when a concurrent tunnel release wins the first claim", () => {
let lookups = 0;
const targets: Array<ManagedEndpointProvider.ManagedEndpointDeprovisionTarget | undefined> = [];
const target = {
userId: "user-1",
environmentId: "environment-1",
hostname: "environment-1.example.test",
tunnelId: "tunnel-1",
tunnelName: "environment-1-tunnel",
dnsRecordId: "dns-1",
readyAt: "2026-07-28T00:00:00.000Z",
origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
updatedAt: "original-generation",
generation: 1,
tunnelReleasedAt: null,
} satisfies ManagedEndpointProvider.ManagedEndpointDeprovisionTarget;
return Effect.gen(function* () {
expect(
yield* unlinkEnvironmentRecord({
userId: "user-1",
environmentId: "environment-1",
}),
).toBe(true);
expect(targets).toEqual([target, target]);
}).pipe(
Effect.provide(
layerRelayUnlinkTest({
getForUser: () => Effect.sync(() => (++lookups === 1 ? linkedEnvironmentRecord : null)),
revokeForUser: () => Effect.succeed(true),
prepareDeprovision: () => Effect.succeed(target),
deprovision: ({ target: captured }) =>
Effect.sync(() => {
targets.push(captured ?? undefined);
return targets.length > 1;
}),
}),
),
);
});
});
describe("relay request tracing", () => {
it.effect(
"does not parent endpoint spans to an ambient parent captured while building handlers",
() =>
Effect.gen(function* () {
const spans: Array<Tracer.NativeSpan> = [];
const tracer = Tracer.make({
span: (options) => {
const span = new Tracer.NativeSpan(options);
spans.push(span);
return span;
},
});
const ambientParent = Tracer.externalSpan({
traceId: "00000000000000000000000000000001",
spanId: "0000000000000001",
sampled: true,
});
const endpoint = yield* withoutCapturedParentSpan(
Effect.context<never>().pipe(
Effect.map((capturedContext: Context.Context<never>) =>
Effect.succeed(HttpServerResponse.empty({ status: 204 })).pipe(
Effect.withSpan("relay.test.endpoint"),
Effect.provideContext(capturedContext),
),
),
),
).pipe(Effect.provideService(Tracer.ParentSpan, ambientParent));
const request = HttpServerRequest.fromWeb(
new Request("https://relay.test/v1/mobile/devices?client=mobile", {
method: "POST",
headers: {
authorization: "Bearer secret",
dpop: "signed-proof",
},
}),
);
yield* traceRelayHttpRequestWith(endpoint, Layer.succeed(Tracer.Tracer, tracer)).pipe(
Effect.provideService(HttpServerRequest.HttpServerRequest, request),
);
expect(spans.map((span) => span.name)).toEqual(["POST", "relay.test.endpoint"]);
expect(spans[0]?.kind).toBe("server");
expect(spans[0]?.attributes.get("url.path")).toBe("/v1/mobile/devices");
expect(spans[0]?.attributes.get("http.response.status_code")).toBe(204);
expect(spans[0]?.attributes.get("http.request.header.authorization")).toBeUndefined();
expect(spans[0]?.attributes.get("http.request.header.dpop")).toBeUndefined();
expect(Option.isNone(spans[0]!.parent)).toBe(true);
expect(Option.getOrUndefined(spans[1]!.parent)?.spanId).toBe(spans[0]?.spanId);
}),
);
});
describe("relay routing fallback", () => {
it.effect("publishes activity for escaped delegated thread IDs longer than 100 characters", () =>
Effect.gen(function* () {
const environmentId = "environment-1";
const environmentPublicKey = "environment-public-key";
const published: Array<
Parameters<AgentActivityPublisher.AgentActivityPublisher["Service"]["publish"]>[0]
> = [];
const verified: Array<
Parameters<
EnvironmentPublishSignatures.EnvironmentPublishSignatures["Service"]["verify"]
>[0]
> = [];
const layerPublisher = Layer.succeed(AgentActivityPublisher.AgentActivityPublisher, {
publish: (input) =>
Effect.sync(() => {
published.push(input);
return { ok: true as const, deliveries: [] };
}),
replayForLiveActivityRegistration: () => Effect.succeed(null),
endIdleLiveActivities: Effect.void,
});
const layerSignatures = Layer.succeed(
EnvironmentPublishSignatures.EnvironmentPublishSignatures,
{
verify: (input) =>
Effect.sync(() => {
verified.push(input);
}),
},
);
const layerAuth = Layer.succeed(RelayEnvironmentAuth, {
environmentBearer: (effect) =>
effect.pipe(
Effect.provideService(RelayEnvironmentPrincipal, {
environmentId,
environmentPublicKey,
}),
),
});
const layerRoutes = HttpApiBuilder.layer(
HttpApi.make("RelayApi").add(RelayApi.groups.server),
).pipe(
Layer.provide(
RelayHttpApi.layerServerApi.pipe(
HttpRouter.provideRequest(
Layer.mergeAll(
Layer.succeed(RelayConfiguration.RelayConfiguration, relaySettings),
Layer.mock(EnvironmentLinks.EnvironmentLinks, {}),
Layer.mock(ManagedEndpointAllocations.ManagedEndpointAllocations, {}),
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
),
),
Layer.provide([layerPublisher, layerSignatures, Layer.mock(HeldHooks.HeldHooks, {})]),
),
),
Layer.provide(layerAuth),
Layer.provide([NodeServices.layer, NodeHttpPlatform.layer, Etag.layerWeak]),
);
const httpEffect = yield* HttpRouter.toHttpEffect(
Layer.mergeAll(layerRoutes, RelayHttpApi.layerNotFoundRoute, RelayHttpApi.layerCors),
).pipe(Effect.provideService(HttpRouter.RouterConfig, RELAY_HTTP_ROUTER_CONFIG));
const threadIds = [
"b7c8c522-d244-43dc-875f-7224fce79912",
"t".repeat(512),
"thread:delegated-task:command%3Amcp%3Ab7c8c522-d244-43dc-875f-7224fce79912%3Adelegate-task%3Agreet-subagent-20260813",
];
for (const threadId of threadIds) {
const request = HttpServerRequest.fromWeb(
new Request(
`https://relay.test/v1/environments/${environmentId}/threads/${encodeURIComponent(threadId)}/agent-activity`,
{
method: "POST",
headers: {
authorization: "Bearer environment-credential",
"content-type": "application/json",
},
body: '{"state":null,"proof":"signed-proof"}',
},
),
);
const response = yield* httpEffect.pipe(
Effect.provideService(HttpServerRequest.HttpServerRequest, request),
);
expect(response.status).toBe(200);
}
expect(published).toEqual(
threadIds.map((threadId) => ({
environmentId,
environmentPublicKey,
threadId,
state: null,
})),
);
expect(verified.map((input) => input.threadId)).toEqual(threadIds);
}).pipe(Effect.scoped, Effect.provide(NodeCryptoLayer.layerSignature)),
);
});
describe("relay CORS", () => {
const origin = "https://app.t3.codes";
class HandlerFailed extends Schema.TaggedError<HandlerFailed>()("HandlerFailed", {}) {}
it.effect("adds CORS headers to handler failures and defects", () =>
Effect.gen(function* () {
const httpEffect = yield* HttpRouter.toHttpEffect(
Layer.mergeAll(
HttpRouter.add("GET", "/v1/fail", Effect.fail(new HandlerFailed())),
HttpRouter.add("GET", "/v1/die", Effect.die(new Error("handler defect"))),
RelayHttpApi.layerNotFoundRoute,
RelayHttpApi.layerCors,
),
);
for (const path of ["/v1/fail", "/v1/die"]) {
const response = yield* sendRelayRequest(
httpEffect,
new Request(`https://relay.test${path}`, { headers: { origin } }),
);
expect(response.status).toBe(500);
expect(response.headers["access-control-allow-origin"]).toBe("*");
expect(response.headers["access-control-expose-headers"]).toBe(
"traceparent,www-authenticate",
);
}
}).pipe(Effect.scoped),
);
});
// Use the Workers request path so pre-response handlers apply.
const sendRelayRequest = Effect.fnUntraced(function* <E, R>(
httpEffect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>,
request: Request,
) {
const sent = yield* Deferred.make<HttpServerResponse.HttpServerResponse>();
yield* HttpEffect.toHandled(httpEffect, (_request, response) =>
Deferred.succeed(sent, response),
).pipe(
Effect.provideService(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)),
Effect.exit,
);
return yield* Deferred.await(sent);
});