sailfork / t3code-github / packages/ shared/ src/ Net.ts

import * as NodeNet from "node:net";

import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Context from "effect/Context";
import * as Predicate from "effect/Predicate";
import * as Schema from "effect/Schema";

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

const isErrnoExceptionWithCode = (
  cause: unknown,
): cause is {
  readonly code: string;
} =>
  Predicate.isObject(cause) &&
  Predicate.hasProperty(cause, "code") &&
  Predicate.isString(cause.code);

const closeServer = (server: NodeNet.Server) => {
  try {
    server.close();
  } catch {}
};

export interface NetServiceShape {
  readonly canListenOnHost: (port: number, host: string) => Effect.Effect<boolean>;

  readonly isPortAvailableOnLoopback: (port: number) => Effect.Effect<boolean>;

  readonly hasListenerOnHost: (port: number, host: string) => Effect.Effect<boolean>;

  readonly reserveLoopbackPort: (host?: string) => Effect.Effect<number, NetError>;

  readonly findAvailablePort: (preferred: number) => Effect.Effect<number, NetError>;
}

export class NetService extends Context.Service<NetService, NetServiceShape>()(
  "@t3tools/shared/Net/NetService",
) {}

/** @public */
export const make = () => {
  const canListenOnHost = (port: number, host: string): Effect.Effect<boolean> =>
    Effect.callback<boolean>((resume) => {
      const server = NodeNet.createServer();
      let settled = false;

      const settle = (value: boolean) => {
        if (settled) return;
        settled = true;
        resume(Effect.succeed(value));
      };

      server.unref();

      server.once("error", (cause) => {
        // Missing IPv6 addresses or kernel support do not mean the port is occupied.
        if (
          isErrnoExceptionWithCode(cause) &&
          (cause.code === "EADDRNOTAVAIL" || cause.code === "EAFNOSUPPORT")
        ) {
          settle(true);
          return;
        }
        settle(false);
      });

      server.once("listening", () => {
        server.close(() => {
          settle(true);
        });
      });

      server.listen({ host, port });

      return Effect.sync(() => {
        closeServer(server);
      });
    });

  const hasListenerOnHost = (port: number, host: string): Effect.Effect<boolean> =>
    Effect.callback<boolean>((resume) => {
      const socket = NodeNet.createConnection({ host, port });
      let settled = false;

      const settle = (value: boolean) => {
        if (settled) return;
        settled = true;
        socket.destroy();
        resume(Effect.succeed(value));
      };

      socket.unref();
      socket.setTimeout(250);
      socket.once("connect", () => {
        settle(true);
      });
      socket.once("error", () => {
        settle(false);
      });
      socket.once("timeout", () => {
        settle(false);
      });

      return Effect.sync(() => {
        socket.destroy();
      });
    });

  const isPortAvailableOnLoopback = Effect.fn("Net.isPortAvailableOnLoopback")(function* (
    port: number,
  ): Effect.fn.Return<boolean> {
    const hasListener = yield* Effect.zipWith(
      hasListenerOnHost(port, "127.0.0.1"),
      hasListenerOnHost(port, "::1"),
      (ipv4, ipv6) => ipv4 || ipv6,
    );
    if (hasListener) {
      return false;
    }

    return yield* Effect.zipWith(
      canListenOnHost(port, "127.0.0.1"),
      canListenOnHost(port, "::1"),
      (ipv4, ipv6) => ipv4 && ipv6,
    );
  });

  const reserveLoopbackPort = (host = "127.0.0.1"): Effect.Effect<number, NetError> =>
    Effect.callback<number, NetError>((resume) => {
      const probe = NodeNet.createServer();
      let settled = false;

      const settle = (effect: Effect.Effect<number, NetError>) => {
        if (settled) return;
        settled = true;
        resume(effect);
      };

      probe.once("error", (cause) => {
        settle(Effect.fail(new NetError({ message: "Failed to reserve loopback port", cause })));
      });

      probe.listen(0, host, () => {
        const address = probe.address();
        const port = typeof address === "object" && address !== null ? address.port : 0;
        probe.close(() => {
          if (port > 0) {
            settle(Effect.succeed(port));
            return;
          }
          settle(Effect.fail(new NetError({ message: "Failed to reserve loopback port" })));
        });
      });

      return Effect.sync(() => {
        closeServer(probe);
      });
    });

  return {
    canListenOnHost,
    isPortAvailableOnLoopback,
    hasListenerOnHost,
    reserveLoopbackPort,
    findAvailablePort: Effect.fn("Net.findAvailablePort")(function* (preferred) {
      if (preferred > 0 && (yield* isPortAvailableOnLoopback(preferred))) {
        return preferred;
      }
      return yield* reserveLoopbackPort();
    }),
  } satisfies NetServiceShape;
};

export const layer = Layer.sync(NetService, make);