sailfork / t3code-github / apps/ mobile/ src/ features/ cloud/ linkEnvironment.ts

import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { HttpClient } from "effect/http";
import {
  EnvironmentCloudEndpointUnavailableError,
  EnvironmentHttpBadRequestError,
  EnvironmentHttpConflictError,
  EnvironmentHttpForbiddenError,
  EnvironmentHttpInternalServerError,
  EnvironmentHttpUnauthorizedError,
} from "@t3tools/contracts";
import {
  type RelayEnvironmentLinkResponse as RelayEnvironmentLinkResponseType,
  type RelayManagedEndpointProviderKind,
} from "@t3tools/contracts/relay";
import { findErrorTraceId } from "@t3tools/client-runtime/errors";
import { ManagedRelay, relayRequestFailureDetail } from "@t3tools/client-runtime/relay";
import { makeEnvironmentHttpApiClient } from "@t3tools/client-runtime/rpc";

import type { SavedRemoteConnection } from "../../lib/connection";
import * as MobileStorage from "../../persistence/mobile-storage";
import { resolveCloudPublicConfig } from "./publicConfig";

function readRelayUrl(): string | null {
  return resolveCloudPublicConfig().relay.url;
}

export class CloudEnvironmentLinkError extends Schema.TaggedError<CloudEnvironmentLinkError>()(
  "CloudEnvironmentLinkError",
  {
    message: Schema.String,
    cause: Schema.optional(Schema.Defect()),
    traceId: Schema.optional(Schema.String),
  },
) {}

const isEnvironmentCloudApiError = Schema.is(
  Schema.Union([
    EnvironmentHttpBadRequestError,
    EnvironmentHttpUnauthorizedError,
    EnvironmentHttpForbiddenError,
    EnvironmentHttpConflictError,
    EnvironmentHttpInternalServerError,
    EnvironmentCloudEndpointUnavailableError,
  ]),
);

const MANAGED_ENDPOINT_PROVIDER_KIND =
  "cloudflare_tunnel" satisfies RelayManagedEndpointProviderKind;

function cloudEnvironmentLinkError(message: string) {
  return (cause: unknown) => {
    const environmentError = findEnvironmentCloudApiError(cause);
    const traceId = findErrorTraceId(cause);
    const detail = environmentError
      ? `${message.replace(/[.:]$/, "")}: ${environmentError.message}`
      : withDevCause(message, cause);
    return new CloudEnvironmentLinkError({
      message: detail,
      cause,
      ...(traceId === null ? {} : { traceId }),
    });
  };
}

function isDevRuntime(): boolean {
  return typeof __DEV__ !== "undefined" && __DEV__;
}

function causeMessage(cause: unknown): string | null {
  if (cause instanceof Error && cause.message) {
    return cause.message;
  }
  if (typeof cause === "object" && cause !== null) {
    const record = cause as { readonly message?: unknown; readonly cause?: unknown };
    if (typeof record.message === "string" && record.message.length > 0) {
      const nested = causeMessage(record.cause);
      return nested ? `${record.message}: ${nested}` : record.message;
    }
  }
  return null;
}

function withDevCause(message: string, cause: unknown): string {
  if (!isDevRuntime()) {
    return message;
  }
  const detail = causeMessage(cause);
  return detail ? `${message} (${detail})` : message;
}

function decodedRelayClientError(message: string) {
  return (cause: ManagedRelay.ManagedRelayClientError) => {
    const failed = cause._tag === "ManagedRelayRequestFailedError" ? cause : undefined;
    const traceId = failed?.traceId;
    const detail = failed ? relayRequestFailureDetail(failed) : null;
    return new CloudEnvironmentLinkError({
      message: detail ? `${message}: ${detail}` : message,
      cause,
      ...(traceId ? { traceId } : {}),
    });
  };
}

function findEnvironmentCloudApiError(cause: unknown): { readonly message: string } | null {
  if (isEnvironmentCloudApiError(cause)) {
    return cause;
  }
  if (typeof cause !== "object" || cause === null) {
    return null;
  }
  return "cause" in cause ? findEnvironmentCloudApiError(cause.cause) : null;
}

function requireRelayUrl(): Effect.Effect<string, CloudEnvironmentLinkError> {
  const relayUrl = readRelayUrl();
  return relayUrl
    ? Effect.succeed(relayUrl)
    : Effect.fail(new CloudEnvironmentLinkError({ message: "Relay URL is not configured." }));
}

function endpointOrigin(httpBaseUrl: string) {
  const url = new URL(httpBaseUrl);
  return {
    localHttpHost: "127.0.0.1",
    localHttpPort: Number(url.port || (url.protocol === "https:" ? 443 : 80)),
  };
}

function ensureLinkedEnvironmentMatches(input: {
  readonly expectedEnvironmentId: string;
  readonly expectedProviderKind: RelayManagedEndpointProviderKind;
  readonly link: RelayEnvironmentLinkResponseType;
}): Effect.Effect<void, CloudEnvironmentLinkError> {
  if (input.link.environmentId !== input.expectedEnvironmentId) {
    return new CloudEnvironmentLinkError({
      message: "Relay returned credentials for a different environment.",
    });
  }
  if (input.link.endpoint.providerKind !== input.expectedProviderKind) {
    return new CloudEnvironmentLinkError({
      message: "Relay returned credentials for a different endpoint provider.",
    });
  }
  return Effect.void;
}

interface LinkEnvironmentToCloudInput {
  readonly connection: SavedRemoteConnection;
  readonly clerkToken: string;
}

type LinkEnvironmentToCloudRequirements =
  | HttpClient.HttpClient
  | ManagedRelay.ManagedRelayClient
  | MobileStorage.MobileStorage;

export const linkEnvironmentToCloudWithPreference = Effect.fn(
  "linkEnvironment.linkEnvironmentToCloudWithPreference",
)(function* (
  input: LinkEnvironmentToCloudInput & { readonly liveActivitiesEnabled: boolean },
): Effect.fn.Return<void, CloudEnvironmentLinkError, LinkEnvironmentToCloudRequirements> {
  if (!input.connection.bearerToken) {
    return yield* new CloudEnvironmentLinkError({
      message: "Only a locally paired bearer connection can be linked to the cloud.",
    });
  }
  const localBearerToken = input.connection.bearerToken;
  const relayUrl = yield* requireRelayUrl();
  const relayClient = yield* ManagedRelay.ManagedRelayClient;
  const storage = yield* MobileStorage.MobileStorage;
  const deviceId = yield* storage.loadOrCreateAgentAwarenessDeviceId.pipe(
    Effect.mapError(cloudEnvironmentLinkError("Could not load the mobile device id.")),
  );
  const liveActivitiesEnabled = input.liveActivitiesEnabled;
  const challenge = yield* relayClient
    .createEnvironmentLinkChallenge({
      clerkToken: input.clerkToken,
      payload: {
        notificationsEnabled: true,
        liveActivitiesEnabled,
        managedTunnelsEnabled: true,
      },
    })
    .pipe(
      Effect.mapError(
        decodedRelayClientError(`${relayUrl}/v1/client/environment-link-challenges failed`),
      ),
    );
  const environmentClient = yield* makeEnvironmentHttpApiClient(input.connection.httpBaseUrl);
  const proof = yield* environmentClient.connect
    .linkProof({
      headers: { authorization: `Bearer ${localBearerToken}` },
      payload: {
        challenge: challenge.challenge,
        relayIssuer: relayUrl,
        endpoint: {
          httpBaseUrl: input.connection.httpBaseUrl,
          wsBaseUrl: input.connection.wsBaseUrl,
          providerKind: MANAGED_ENDPOINT_PROVIDER_KIND,
        },
        origin: endpointOrigin(input.connection.httpBaseUrl),
      },
    })
    .pipe(Effect.mapError(cloudEnvironmentLinkError("Could not obtain environment link proof.")));
  const link = yield* relayClient
    .linkEnvironment({
      clerkToken: input.clerkToken,
      payload: {
        deviceId,
        proof,
        notificationsEnabled: true,
        liveActivitiesEnabled,
        managedTunnelsEnabled: true,
      },
    })
    .pipe(
      Effect.mapError(decodedRelayClientError(`${relayUrl}/v1/client/environment-links failed`)),
    );
  yield* ensureLinkedEnvironmentMatches({
    expectedEnvironmentId: input.connection.environmentId,
    expectedProviderKind: MANAGED_ENDPOINT_PROVIDER_KIND,
    link,
  });

  yield* environmentClient.connect
    .relayConfig({
      headers: { authorization: `Bearer ${localBearerToken}` },
      payload: {
        relayUrl,
        relayIssuer: link.relayIssuer,
        cloudUserId: link.cloudUserId,
        environmentCredential: link.environmentCredential,
        cloudMintPublicKey: link.cloudMintPublicKey,
        endpointRuntime: link.endpointRuntime,
      },
    })
    .pipe(
      Effect.mapError(cloudEnvironmentLinkError("Could not configure environment relay access.")),
    );
});