sailfork / t3code-github / packages/ provider-acp-registry/ src/ server/ authenticationState.ts

import type { ProviderInstanceEnvironment, ProviderInstanceId } from "@t3tools/contracts";
import type { AcpRegistrySettings } from "../settings.ts";
import * as Digest from "effect/crypto/Digest";
import * as Effect from "effect/Effect";
import * as Hex from "effect/encoding/Hex";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import * as Semaphore from "effect/Semaphore";

import { writeFileStringAtomically } from "@t3tools/shared/atomicWrite";

const decodeState = Schema.decodeUnknownEffect(
  Schema.fromJsonString(Schema.Struct({ binding: Schema.String, authenticated: Schema.Boolean })),
);
const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown));
const hash = Effect.fn("AcpRegistryAuthenticationState.hash")(function* (value: unknown) {
  const crypto = yield* Digest.Digest;
  const json = yield* encodeJson(value).pipe(Effect.orDie);
  const digest = yield* crypto
    .digest(Digest.sha256, new TextEncoder().encode(json))
    .pipe(Effect.orDie);
  return Hex.encode(digest);
});

export const makeAcpRegistryAuthenticationState = Effect.fn("makeAcpRegistryAuthenticationState")(
  function* (input: {
    readonly cacheDir: string;
    readonly instanceId: ProviderInstanceId;
    readonly settings: AcpRegistrySettings;
    readonly environment: ProviderInstanceEnvironment;
    readonly processEnvironment: NodeJS.ProcessEnv;
  }) {
    const fs = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const filePath = path.join(input.cacheDir, `acp-auth-${yield* hash(input.instanceId)}.json`);
    // Cosmetic settings and model discovery do not change the account binding.
    const binding = yield* hash({
      ...(input.settings.source === "local"
        ? { source: "local", commandArgs: input.settings.commandArgs }
        : {}),
      agentId: input.settings.agentId,
      commandPath: input.settings.commandPath,
      distribution: input.settings.distribution,
      authMethodId: input.settings.authMethodId,
      environment: [...input.environment].toSorted((a, b) => a.name.localeCompare(b.name)),
      profiles: [
        "HOME",
        "XDG_CONFIG_HOME",
        "XDG_DATA_HOME",
        "XDG_STATE_HOME",
        "APPDATA",
        "LOCALAPPDATA",
      ].map((name) => input.processEnvironment[name] ?? null),
    });
    const saved = yield* fs.readFileString(filePath).pipe(
      Effect.flatMap(decodeState),
      Effect.orElseSucceed(() => undefined),
    );
    const confirmed = yield* Ref.make(saved?.binding === binding && saved.authenticated);
    const lock = yield* Semaphore.make(1);
    const persist = (authenticated: boolean) =>
      writeFileStringAtomically({
        filePath,
        contents: JSON.stringify({ binding, authenticated }),
      }).pipe(
        Effect.provideService(FileSystem.FileSystem, fs),
        Effect.provideService(Path.Path, path),
        Effect.tapError(() => Effect.logWarning("Could not save ACP sign-in confirmation.")),
        Effect.ignore,
      );
    if (saved && saved.binding !== binding) yield* persist(false);
    return {
      get: Ref.get(confirmed),
      set: (authenticated: boolean) =>
        lock.withPermit(
          Ref.set(confirmed, authenticated).pipe(Effect.andThen(persist(authenticated))),
        ),
    };
  },
);