sailfork / t3code-github / apps/ server/ src/ auth/ EnvironmentAuthAdmin.test.ts

import { AuthStandardClientScopes, type ManagedPolicyDocument } from "@t3tools/contracts";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import * as ServerConfig from "../config.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as EnvironmentAuth from "./EnvironmentAuth.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
import * as SessionStore from "./SessionStore.ts";
import * as PairingGrantStore from "./PairingGrantStore.ts";
import * as ManagedPolicy from "../policy/ManagedPolicy.ts";

const layerServerConfig = (
  overrides?: Partial<Pick<ServerConfig.ServerConfig["Service"], "desktopBootstrapToken">>,
) =>
  Layer.effect(
    ServerConfig.ServerConfig,
    Effect.gen(function* () {
      const config = yield* ServerConfig.ServerConfig;
      return {
        ...config,
        ...overrides,
      } satisfies ServerConfig.ServerConfig["Service"];
    }),
  ).pipe(
    Layer.provide(
      ServerConfig.layerTest(process.cwd(), {
        prefix: "t3-auth-control-plane-test-",
      }),
    ),
  );

const layerEnvironmentAuth = (
  overrides?: Partial<Pick<ServerConfig.ServerConfig["Service"], "desktopBootstrapToken">>,
  policy?: ManagedPolicyDocument,
) =>
  EnvironmentAuth.layer.pipe(
    Layer.provide(ManagedPolicy.layerTest(policy)),
    Layer.provideMerge(ServerSecretStore.layer),
    Layer.provideMerge(SqlitePersistence.layerMemory),
    Layer.provide(ServerEnvironment.layerIdentity),
    Layer.provide(layerServerConfig(overrides)),
  );

const desktopAndLocalOnly: ManagedPolicyDocument = {
  schemaVersion: 1,
  organization: "Example Corp",
  limits: { clients: ["desktop", "local-browser"] },
};

it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))(
  "EnvironmentAuth administrative operations",
  (it) => {
    it.effect("refuses pairing links when the policy does not allow remote clients", () =>
      Effect.gen(function* () {
        const environmentAuth = yield* EnvironmentAuth.EnvironmentAuth;

        const error = yield* environmentAuth.issuePairingCredential().pipe(Effect.flip);
        const startup = yield* environmentAuth.issueStartupPairingCredential();

        assert.equal(
          error.message,
          "Example Corp's policy does not allow remote clients, so this server cannot create pairing links.",
        );
        assert.isAbove(startup.credential.length, 0);
      }).pipe(Effect.provide(layerEnvironmentAuth(undefined, desktopAndLocalOnly))),
    );

    it.effect("revokes link-paired clients on startup under a policy without remote clients", () =>
      Effect.gen(function* () {
        const sessions = yield* SessionStore.SessionStore;
        const pairingLinks = yield* PairingGrantStore.PairingGrantStore;
        const environmentAuth = yield* EnvironmentAuth.EnvironmentAuth;
        const phone = yield* sessions.issue({ subject: "one-time-token" });
        const bot = yield* sessions.issue({ subject: "cli-issued-session" });
        const startup = (ipAddress: string) =>
          sessions.issue({
            subject: EnvironmentAuth.INTERNAL_ADMINISTRATIVE_BOOTSTRAP_SUBJECT,
            client: { deviceType: "unknown", ipAddress },
          });
        const startupPhone = yield* startup("192.168.1.20");
        const startupBrowser = yield* startup("127.0.0.1");
        yield* environmentAuth.createPairingLink({ subject: "one-time-token" });

        yield* EnvironmentAuth.make.pipe(
          Effect.provide(
            Layer.merge(ManagedPolicy.layerTest(desktopAndLocalOnly), layerServerConfig()),
          ),
        );

        const remaining = (yield* sessions.listActive()).map((session) => session.sessionId);
        assert.notInclude(remaining, phone.sessionId);
        assert.notInclude(remaining, startupPhone.sessionId);
        assert.include(remaining, startupBrowser.sessionId);
        assert.include(remaining, bot.sessionId);
        assert.lengthOf(yield* pairingLinks.listActive(), 0);
      }).pipe(Effect.provide(layerEnvironmentAuth())),
    );

    it.effect("revokes only T3 Connect clients when the policy keeps remote clients", () =>
      Effect.gen(function* () {
        const sessions = yield* SessionStore.SessionStore;
        const phone = yield* sessions.issue({ subject: "one-time-token" });
        const connect = yield* sessions.issue({ subject: "cloud-connect" });

        yield* EnvironmentAuth.make.pipe(
          Effect.provide(
            Layer.merge(
              ManagedPolicy.layerTest({
                schemaVersion: 1,
                organization: "Example Corp",
                limits: { connect: false },
              }),
              layerServerConfig(),
            ),
          ),
        );

        const remaining = (yield* sessions.listActive()).map((session) => session.sessionId);
        assert.include(remaining, phone.sessionId);
        assert.notInclude(remaining, connect.sessionId);
      }).pipe(Effect.provide(layerEnvironmentAuth())),
    );

    it.effect("creates, lists, and revokes client pairing links", () =>
      Effect.gen(function* () {
        const environmentAuth = yield* EnvironmentAuth.EnvironmentAuth;

        const created = yield* environmentAuth.createPairingLink({
          scopes: ["orchestration:read"],
          subject: "one-time-token",
          label: "CI phone",
        });
        const listedBeforeRevoke = yield* environmentAuth.listPairingLinks();
        const revoked = yield* environmentAuth.revokePairingLink(created.id);
        const listedAfterRevoke = yield* environmentAuth.listPairingLinks();

        expect(created.scopes).toEqual(["orchestration:read"]);
        expect(created.credential.length).toBeGreaterThan(0);
        expect(listedBeforeRevoke).toHaveLength(1);
        expect(listedBeforeRevoke[0]?.id).toBe(created.id);
        expect(listedBeforeRevoke[0]?.label).toBe("CI phone");
        expect(listedBeforeRevoke[0]).not.toHaveProperty("credential");
        expect(revoked).toBe(true);
        expect(listedAfterRevoke).toHaveLength(0);
      }).pipe(Effect.provide(layerEnvironmentAuth())),
    );

    it.effect("issues bearer access token sessions without exposing raw tokens", () =>
      Effect.gen(function* () {
        const environmentAuth = yield* EnvironmentAuth.EnvironmentAuth;
        const sessionCredentials = yield* SessionStore.SessionStore;

        const issued = yield* environmentAuth.issueSession({
          label: "deploy-bot",
        });
        const verified = yield* sessionCredentials.verify(issued.token);
        const listedBeforeRevoke = yield* environmentAuth.listSessions();
        const revoked = yield* environmentAuth.revokeSession(issued.sessionId);
        const listedAfterRevoke = yield* environmentAuth.listSessions();

        expect(issued.method).toBe("bearer-access-token");
        expect(issued.scopes).toEqual(AuthStandardClientScopes);
        expect(issued.client.deviceType).toBe("bot");
        expect(issued.client.label).toBe("deploy-bot");
        expect(verified.sessionId).toBe(issued.sessionId);
        expect(verified.scopes).toEqual(AuthStandardClientScopes);
        expect(verified.method).toBe("bearer-access-token");
        expect(listedBeforeRevoke).toHaveLength(1);
        expect(listedBeforeRevoke[0]?.sessionId).toBe(issued.sessionId);
        expect("token" in (listedBeforeRevoke[0] ?? {})).toBe(false);
        expect(revoked).toBe(true);
        expect(listedAfterRevoke).toHaveLength(0);
      }).pipe(Effect.provide(layerEnvironmentAuth())),
    );
  },
);