sailfork / t3code-github / apps/ server/ src/ provider/ CodexManagedTokenBroker.ts

// @effect-diagnostics nodeBuiltinImport:off - Server-owned private pipe/Unix socket, never a public listener.
import * as NodeFSP from "node:fs/promises";
import * as NodeNet from "node:net";
import * as NodeOS from "node:os";
import * as NodePath from "node:path";
import * as NodeCrypto from "node:crypto";
import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as FiberSet from "effect/FiberSet";
import * as Layer from "effect/Layer";
import * as Exit from "effect/Exit";
import * as Scope from "effect/Scope";
import * as Schema from "effect/Schema";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import { makeCodexChatGptAuth } from "./CodexChatGptAuth.ts";
import * as Protocol from "./CodexManagedTokenProtocol.ts";

const MAX_CONNECTIONS = 32;
const MAX_JOBS = 16;
// Stay below macOS's 104-byte and Linux's 108-byte sockaddr_un limits, including NUL.
const UNIX_SOCKET_PATH_BYTES = 100;
const encodeResponse = Schema.encodeSync(Schema.fromJsonString(Protocol.Response));
class BrokerStartError extends Schema.TaggedError<BrokerStartError>()(
  "ManagedTokenBrokerStartError",
  {
    cause: Schema.Defect(),
  },
) {
  override get message() {
    return "Could not start the private managed token listener.";
  }
}
export class CodexManagedTokenBroker extends Context.Service<
  CodexManagedTokenBroker,
  {
    readonly endpoint: Effect.Effect<string, BrokerStartError>;
    readonly awaitIdle: Effect.Effect<void>;
  }
>()("t3/provider/CodexManagedTokenBroker") {}

const io = <A>(f: () => Promise<A>) =>
  Effect.tryPromise({ try: f, catch: (cause) => new BrokerStartError({ cause }) });
const acquireListener = Effect.gen(function* () {
  const identity = yield* ServerEnvironment.ServerEnvironmentIdentity;
  const environmentId = yield* identity.getEnvironmentId;
  const platform = yield* HostProcess.Platform;
  const uid = yield* HostProcess.UserId;
  const owned = yield* Effect.acquireRelease(
    io(async () => {
      if (platform === "win32")
        return { endpoint: `\\\\.\\pipe\\t3-token-${NodeCrypto.randomUUID()}` };
      if (uid === undefined) throw new Error("Missing IPC owner");
      const acquireDirectory = async (candidate: string) => {
        const parent = await NodeFSP.realpath(candidate);
        const stat = await NodeFSP.lstat(parent);
        if (
          !stat.isDirectory() ||
          stat.isSymbolicLink() ||
          !(
            (stat.uid === uid && (stat.mode & 0o022) === 0) ||
            (stat.uid === 0 && ((stat.mode & 0o022) === 0 || (stat.mode & 0o1000) !== 0))
          )
        )
          throw new Error("Untrusted IPC parent");
        const directory = await NodeFSP.mkdtemp(NodePath.join(parent, "t3-token-"));
        try {
          await NodeFSP.chmod(directory, 0o700);
          const created = await NodeFSP.lstat(directory);
          if (
            !created.isDirectory() ||
            created.isSymbolicLink() ||
            created.uid !== uid ||
            (created.mode & 0o777) !== 0o700
          )
            throw new Error("Unprotected IPC directory");
          const endpoint = NodePath.join(directory, "s");
          if (Buffer.byteLength(endpoint) > UNIX_SOCKET_PATH_BYTES)
            throw new Error("IPC path too long");
          return { endpoint, directory, created };
        } catch (error) {
          await NodeFSP.rmdir(directory);
          throw error;
        }
      };
      return acquireDirectory(NodeOS.tmpdir()).catch(() => acquireDirectory("/tmp"));
    }),
    (owned) =>
      Effect.promise(async () => {
        if (!("directory" in owned)) return;
        // Never recursively remove a replaced directory or another process's files.
        const current = await NodeFSP.lstat(owned.directory).catch(() => undefined);
        if (
          current &&
          current.dev === owned.created.dev &&
          current.ino === owned.created.ino &&
          !current.isSymbolicLink()
        )
          await NodeFSP.rmdir(owned.directory).catch(() => undefined);
      }),
  );
  const jobs = yield* FiberSet.make<void>();
  const runJob =
    yield* FiberSet.runtime(jobs)<
      Exclude<
        Effect.Services<ReturnType<typeof makeCodexChatGptAuth>>,
        import("effect/Scope").Scope
      >
    >();
  const connections = yield* FiberSet.make<void>();
  const runConnection = yield* FiberSet.runtime(connections)();
  const sockets = new Set<NodeNet.Socket>();
  let closing = false;
  let admitted = 0;
  // Keep branded validation here so the helper need not load the contracts graph.
  const decode = Schema.decodeUnknownEffect(
    Schema.fromJsonString(
      Schema.Struct({
        ...Protocol.Request.fields,
        instanceId: ProviderInstanceId,
        environmentId: EnvironmentId,
      }),
    ),
    {
      onExcessProperty: "error",
    },
  );
  const server = NodeNet.createServer((socket) => {
    socket.on("error", () => {});
    if (closing || sockets.size >= MAX_CONNECTIONS) {
      socket.destroy();
      return;
    }
    sockets.add(socket);
    socket.once("close", () => sockets.delete(socket));
    let transferred = false;
    runConnection(
      Effect.gen(function* () {
        // Windows pipes permit read-only peers by default; send no bytes until a complete request.
        const request = yield* Protocol.readFrame(
          socket,
          Protocol.REQUEST_BYTES,
          Protocol.SOCKET_IDLE_MS,
        ).pipe(Effect.flatMap(decode));
        if (closing || admitted >= MAX_JOBS || request.environmentId !== environmentId) return;
        admitted++;
        transferred = true;
        runJob(
          Effect.scoped(
            Effect.gen(function* () {
              const auth = yield* makeCodexChatGptAuth({
                instanceId: request.instanceId,
                expectedProfileKey: request.profileKey,
              });
              // Retire abandoned permit waits; access saves a started rotation before honoring interruption.
              const credentials = yield* auth.access.pipe(
                Effect.timeout(Protocol.COMMAND_TIMEOUT_MS),
              );
              yield* Protocol.writeFrame(
                socket,
                encodeResponse({ token: credentials.accessToken }),
                Protocol.RESPONSE_BYTES,
              );
            }),
          ).pipe(
            Effect.ignoreCause,
            Effect.ensuring(
              Effect.sync(() => {
                admitted--;
                socket.destroy();
              }),
            ),
          ),
        );
      }).pipe(
        Effect.ignoreCause,
        Effect.ensuring(
          Effect.sync(() => {
            if (!transferred) socket.destroy();
          }),
        ),
      ),
    );
  });
  server.on("error", () => {});
  // Drain accepted rotations before the FiberSet finalizers interrupt their fibers.
  yield* Effect.addFinalizer(() =>
    Effect.gen(function* () {
      closing = true;
      for (const socket of sockets) socket.destroy();
      yield* Effect.promise(() => new Promise<void>((resolve) => server.close(() => resolve())));
      yield* FiberSet.awaitEmpty(connections);
      yield* FiberSet.awaitEmpty(jobs);
    }),
  );
  yield* Effect.callback<void, BrokerStartError>((resume) => {
    const onError = (cause: Error) => resume(Effect.fail(new BrokerStartError({ cause })));
    server.once("error", onError);
    try {
      server.listen(owned.endpoint, () => resume(Effect.void));
    } catch (cause) {
      resume(Effect.fail(new BrokerStartError({ cause })));
    }
    return Effect.sync(() => server.off("error", onError));
  });
  if (platform !== "win32") yield* io(() => NodeFSP.chmod(owned.endpoint, 0o600));
  return { endpoint: owned.endpoint, awaitIdle: FiberSet.awaitEmpty(jobs) };
});
const make = Effect.gen(function* () {
  const scope = yield* Scope.fork(yield* Effect.scope);
  const acquired = yield* acquireListener.pipe(Scope.provide(scope), Effect.result);
  if (acquired._tag === "Failure") {
    yield* Scope.close(scope, Exit.fail(acquired.failure));
    return CodexManagedTokenBroker.of({
      endpoint: Effect.fail(acquired.failure),
      awaitIdle: Effect.void,
    });
  }
  return CodexManagedTokenBroker.of({
    endpoint: Effect.succeed(acquired.success.endpoint),
    awaitIdle: acquired.success.awaitIdle,
  });
});
export const layer = Layer.effect(CodexManagedTokenBroker, make);