sailfork / t3code-github / apps/ server/ src/ cloud/ CloudLink.test.ts

import { EnvironmentId } from "@t3tools/contracts";
import { assert, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import { HttpClient, HttpServer } from "effect/http";
import * as NetAddress from "effect/net/NetAddress";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";

import * as EnvironmentKeys from "./environmentKeys.ts";
import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
import * as ServerConfig from "../config.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as AgentAwarenessRelay from "../relay/AgentAwarenessRelay.ts";
import * as CliTokenManager from "./CliTokenManager.ts";
import * as CloudLink from "./CloudLink.ts";
import * as ConnectReachability from "./ConnectReachability.ts";
import * as ManagedEndpointRuntime from "./ManagedEndpointRuntime.ts";
import {
  CLOUD_LINKED_USER_ID,
  HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET,
  PUBLISH_AGENT_ACTIVITY_SECRET,
  RELAY_ENVIRONMENT_CREDENTIAL_SECRET,
  RELAY_URL_SECRET,
} from "./config.ts";
import * as ManagedPolicy from "../policy/ManagedPolicy.ts";

const encode = (value: string) => new TextEncoder().encode(value);

const withService = <A, E>(
  options: {
    readonly failHoldWrite?: boolean;
    readonly failActivityWrite?: boolean;
    readonly relayFails?: boolean;
    readonly failActivityRead?: boolean;
    readonly failHoldRead?: boolean;
    readonly holdFirstRelayCall?: {
      readonly started: () => void;
      readonly released: Promise<void>;
    };
  },
  body: (input: {
    readonly preferences: { readonly update: CloudLink.CloudLink["Service"]["updatePreferences"] };
    readonly stored: Map<string, Uint8Array>;
    readonly relayCalls: Array<boolean>;
  }) => Effect.Effect<A, E, never>,
) =>
  Effect.gen(function* () {
    const stored = new Map<string, Uint8Array>([
      [RELAY_URL_SECRET, encode("https://relay.test")],
      [RELAY_ENVIRONMENT_CREDENTIAL_SECRET, encode("credential")],
      [HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET, encode("false")],
      [PUBLISH_AGENT_ACTIVITY_SECRET, encode("false")],
    ]);
    const relayCalls: Array<boolean> = [];
    const fetch: typeof globalThis.fetch = Object.assign(
      (_input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
        const payload = JSON.parse(String(init?.body)) as { holdWebhooksWhileOffline: boolean };
        relayCalls.push(payload.holdWebhooksWhileOffline);
        if (relayCalls.length === 1 && options.holdFirstRelayCall) {
          options.holdFirstRelayCall.started();
          return options.holdFirstRelayCall.released.then(() => Response.json(payload));
        }
        return options.relayFails
          ? Promise.resolve(new Response("unavailable", { status: 503 }))
          : Promise.resolve(Response.json(payload));
      },
      { preconnect: () => {} },
    );
    const layerDependencies = Layer.mergeAll(
      Layer.mock(ServerSecretStore.ServerSecretStore)({
        get: (name) =>
          (options.failActivityRead && name === PUBLISH_AGENT_ACTIVITY_SECRET) ||
          (options.failHoldRead && name === HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)
            ? Effect.fail(
                new ServerSecretStore.SecretStoreReadError({
                  resource: name,
                  cause: new Error("busy"),
                }),
              )
            : Effect.succeed(Option.fromNullishOr(stored.get(name))),
        set: (name, value) =>
          (options.failHoldWrite && name === HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET) ||
          (options.failActivityWrite && name === PUBLISH_AGENT_ACTIVITY_SECRET)
            ? Effect.fail(
                new ServerSecretStore.SecretStorePersistError({
                  resource: name,
                  cause: new Error("read-only"),
                }),
              )
            : Effect.sync(() => void stored.set(name, value)),
      }),
      Layer.mock(ServerEnvironment.ServerEnvironment)({
        getEnvironmentId: Effect.succeed(EnvironmentId.make("environment-1")),
      }),
      Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({ requestCatchUp: () => Effect.void }),
      Layer.mock(ManagedEndpointRuntime.CloudManagedEndpointRuntime)({}),
      ManagedPolicy.layerTest(),
      Layer.mock(ConnectReachability.ConnectReachability)({
        latest: Effect.succeedNone,
      }),
      Layer.mock(EnvironmentAuth.EnvironmentAuth)({}),
      Layer.mock(CliTokenManager.CloudCliTokenManager)({}),
      Layer.mock(HttpServer.HttpServer)({
        address: NetAddress.inetAddressFromIpStringUnsafe("127.0.0.1", 3773),
      }),
      Layer.mock(ServerConfig.ServerConfig)({} as ServerConfig.ServerConfig["Service"]),
      Layer.succeed(
        HttpClient.HttpClient,
        HttpClient.make(() => Effect.die("unused")),
      ),
      NodeServices.layer,
      NodeCrypto.layer,
    );
    return yield* Effect.gen(function* () {
      const link = yield* CloudLink.CloudLink;
      return yield* body({ preferences: { update: link.updatePreferences }, stored, relayCalls });
    }).pipe(
      Effect.provide(
        CloudLink.layer.pipe(
          // These tests never sign proofs; the mocked secret store cannot create a key pair.
          Layer.provide(Layer.mock(EnvironmentKeys.EnvironmentSigningKey)({ publicKey: "" })),
          Layer.provide(layerDependencies),
        ),
      ),
      Effect.provideService(FetchHttpClient.Fetch, fetch),
    );
  });

it.effect("tells the relay before saving the hold setting locally", () =>
  withService({}, ({ preferences, stored, relayCalls }) =>
    Effect.gen(function* () {
      yield* preferences.update({ publishAgentActivity: true, holdWebhooksWhileOffline: true });
      assert.deepEqual(relayCalls, [true]);
      assert.equal(
        new TextDecoder().decode(stored.get(HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)),
        "true",
      );
    }),
  ),
);

it.effect("puts the relay back when the local save fails", () =>
  withService({ failHoldWrite: true }, ({ preferences, stored, relayCalls }) =>
    Effect.gen(function* () {
      const error = yield* preferences
        .update({ publishAgentActivity: true, holdWebhooksWhileOffline: true })
        .pipe(Effect.flip);
      assert.deepInclude(error, {
        _tag: "CloudLinkInternalError",
        operation: "persist-preferences",
      });
      assert.deepEqual(relayCalls, [true, false]);
      assert.equal(
        new TextDecoder().decode(stored.get(HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)),
        "false",
      );
    }),
  ),
);

it.effect("leaves the relay untouched when the activity setting can't be saved", () =>
  withService({ failActivityWrite: true }, ({ preferences, stored, relayCalls }) =>
    Effect.gen(function* () {
      const error = yield* preferences
        .update({ publishAgentActivity: true, holdWebhooksWhileOffline: true })
        .pipe(Effect.flip);
      assert.deepInclude(error, {
        _tag: "CloudLinkInternalError",
        operation: "persist-preferences",
      });
      assert.deepEqual(relayCalls, []);
      assert.equal(
        new TextDecoder().decode(stored.get(HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)),
        "false",
      );
    }),
  ),
);

it.effect("keeps both settings unchanged when the relay refuses the hold change", () =>
  withService({ relayFails: true }, ({ preferences, stored }) =>
    Effect.gen(function* () {
      yield* preferences
        .update({ publishAgentActivity: true, holdWebhooksWhileOffline: true })
        .pipe(Effect.flip);
      assert.equal(new TextDecoder().decode(stored.get(PUBLISH_AGENT_ACTIVITY_SECRET)), "false");
      assert.equal(
        new TextDecoder().decode(stored.get(HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)),
        "false",
      );
    }),
  ),
);

it.effect("two overlapping updates are applied one after the other", () => {
  let release!: () => void;
  let started!: () => void;
  const released = new Promise<void>((resolve) => {
    release = resolve;
  });
  const firstAtRelay = new Promise<void>((resolve) => {
    started = resolve;
  });
  return withService({ holdFirstRelayCall: { started, released } }, ({ preferences, stored }) =>
    Effect.gen(function* () {
      const first = yield* preferences
        .update({ publishAgentActivity: true, holdWebhooksWhileOffline: true })
        .pipe(Effect.forkChild);
      yield* Effect.promise(() => firstAtRelay);
      const second = yield* preferences
        .update({ publishAgentActivity: false, holdWebhooksWhileOffline: false })
        .pipe(Effect.forkChild);
      yield* Effect.yieldNow;
      assert.equal(new TextDecoder().decode(stored.get(PUBLISH_AGENT_ACTIVITY_SECRET)), "true");
      release();
      yield* Fiber.join(first);
      yield* Fiber.join(second);
      assert.equal(new TextDecoder().decode(stored.get(PUBLISH_AGENT_ACTIVITY_SECRET)), "false");
      assert.equal(
        new TextDecoder().decode(stored.get(HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)),
        "false",
      );
    }),
  );
});

it.effect("an update the client walks away from still finishes", () => {
  let release!: () => void;
  let started!: () => void;
  const released = new Promise<void>((resolve) => {
    release = resolve;
  });
  const atRelay = new Promise<void>((resolve) => {
    started = resolve;
  });
  return withService({ holdFirstRelayCall: { started, released } }, ({ preferences, stored }) =>
    Effect.gen(function* () {
      const update = yield* preferences
        .update({ publishAgentActivity: true, holdWebhooksWhileOffline: true })
        .pipe(Effect.forkChild);
      yield* Effect.promise(() => atRelay);
      const interrupted = yield* Fiber.interrupt(update).pipe(Effect.forkChild);
      yield* Effect.yieldNow;
      release();
      yield* Fiber.join(interrupted);
      assert.equal(new TextDecoder().decode(stored.get(PUBLISH_AGENT_ACTIVITY_SECRET)), "true");
      assert.equal(
        new TextDecoder().decode(stored.get(HOLD_WEBHOOKS_WHILE_OFFLINE_SECRET)),
        "true",
      );
    }),
  );
});

it.effect("unlinks on startup and refuses to link when the policy turns Connect off", () =>
  Effect.gen(function* () {
    const stored = new Map<string, Uint8Array>([
      [CLOUD_LINKED_USER_ID, encode("user-1")],
      [RELAY_URL_SECRET, encode("https://relay.test")],
    ]);
    const appliedConfigs: Array<unknown> = [];
    const layerDependencies = Layer.mergeAll(
      Layer.mock(ServerSecretStore.ServerSecretStore)({
        get: (name) => Effect.succeed(Option.fromNullishOr(stored.get(name))),
        set: (name, value) => Effect.sync(() => void stored.set(name, value)),
        remove: (name) => Effect.sync(() => void stored.delete(name)),
      }),
      Layer.mock(ServerEnvironment.ServerEnvironment)({}),
      Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({}),
      Layer.mock(ManagedEndpointRuntime.CloudManagedEndpointRuntime)({
        withLinkStateLock: (effect) => effect,
        applyConfig: (config) =>
          Effect.sync(() => {
            appliedConfigs.push(config);
            return { status: "disabled" as const };
          }),
      }),
      ManagedPolicy.layerTest({
        schemaVersion: 1,
        organization: "Example Corp",
        limits: { connect: false },
      }),
      Layer.mock(ConnectReachability.ConnectReachability)({}),
      Layer.mock(EnvironmentAuth.EnvironmentAuth)({}),
      Layer.mock(CliTokenManager.CloudCliTokenManager)({}),
      Layer.mock(HttpServer.HttpServer)({
        address: NetAddress.inetAddressFromIpStringUnsafe("127.0.0.1", 3773),
      }),
      Layer.mock(ServerConfig.ServerConfig)({} as ServerConfig.ServerConfig["Service"]),
      Layer.succeed(
        HttpClient.HttpClient,
        HttpClient.make(() => Effect.die("unused")),
      ),
      NodeServices.layer,
      NodeCrypto.layer,
    );
    yield* Effect.gen(function* () {
      const link = yield* CloudLink.CloudLink;
      assert.isFalse(stored.has(CLOUD_LINKED_USER_ID));
      assert.deepEqual(appliedConfigs, [null]);

      const applyError = yield* link.applyRelayConfig({} as never).pipe(Effect.flip);
      const mintError = yield* link.mintCredential({} as never).pipe(Effect.flip);
      assert.equal(applyError.message, "Example Corp's policy does not allow T3 Connect.");
      assert.equal(mintError._tag, "ManagedPolicyRefusedError");
    }).pipe(
      Effect.provide(
        CloudLink.layer.pipe(
          // These tests never sign proofs; the mocked secret store cannot create a key pair.
          Layer.provide(Layer.mock(EnvironmentKeys.EnvironmentSigningKey)({ publicKey: "" })),
          Layer.provide(layerDependencies),
        ),
      ),
    );
  }),
);