sailfork / t3code-github / infra/ relay/ src/ http/ Api.test.ts

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);
});