import { Buffer } from "node:buffer"; import { Effect, Layer, Option, Schema, Stream } from "effect";import { HttpClient, HttpClientRequest } from "effect/unstable/http"; import type { WebPortInspectorShape } from "../Services/WebPortInspector.ts";import { WebPortInspector, WebPortInspectionError } from "../Services/WebPortInspector.ts"; const DEFAULT_WEB_PORT_PROBE_TIMEOUT_MS = 2_000;const WEB_PORT_PROBE_MAX_BODY_BYTES = 8_192; interface WebProbeResult {  readonly status: number;  readonly contentType: string;  readonly body: string;  readonly location: string;} function normalizeHeaderValue(value: string | string[] | undefined): string {  if (typeof value === "string") return value;  if (Array.isArray(value)) return value[0] ?? "";  return "";} function isLikelyWebProbe(result: WebProbeResult | null): boolean {  if (!result) return false;  if (result.status === 404) return false;  if (result.status >= 300 && result.status < 400 && result.location.length > 0) {    return true;  }  const contentType = result.contentType.toLowerCase();  if (contentType.includes("text/html") || contentType.includes("application/xhtml+xml")) {    return true;  }  const body = result.body.toLowerCase();  return body.includes("<!doctype") || body.includes("<html") || body.includes("<head");} const collectBodyPreview = <E>(  stream: Stream.Stream<Uint8Array, E>,): Effect.Effect<string, never> =>  stream.pipe(    Stream.decodeText(),    Stream.runFold(      () => ({        text: "",        bytes: 0,      }),      (state, chunk) => {        if (state.bytes >= WEB_PORT_PROBE_MAX_BODY_BYTES) {          return state;        }         const chunkBytes = Buffer.byteLength(chunk);        const remainingBytes = WEB_PORT_PROBE_MAX_BODY_BYTES - state.bytes;        if (chunkBytes <= remainingBytes) {          return {            text: `${state.text}${chunk}`,            bytes: state.bytes + chunkBytes,          };        }         return {          text: `${state.text}${Buffer.from(chunk).subarray(0, remainingBytes).toString("utf8")}`,          bytes: state.bytes + remainingBytes,        };      },    ),    Effect.map((preview) => preview.text),    Effect.orElseSucceed(() => ""),  ); const makeWebPortInspector = Effect.gen(function* () {  const httpClient = yield* HttpClient.HttpClient;   const probeWebPortOnHost = Effect.fn("process.probeWebPortOnHost")(function* (    port: number,    host: string,  ): Effect.fn.Return<WebProbeResult | null, WebPortInspectionError> {    const request = HttpClientRequest.get(`http://${host}:${port}/`).pipe(      HttpClientRequest.setHeaders({        accept: "text/html,application/xhtml+xml;q=1,*/*;q=0.1",      }),    );     return yield* httpClient.execute(request).pipe(      Effect.flatMap((response) =>        Effect.gen(function* () {          const status = response.status;          const contentType = normalizeHeaderValue(response.headers["content-type"]);          const location = normalizeHeaderValue(response.headers.location);           if (            (status >= 300 && status < 400 && location.length > 0) ||            contentType.toLowerCase().includes("text/html") ||            contentType.toLowerCase().includes("application/xhtml+xml")          ) {            return {              status,              contentType,              location,              body: "",            } satisfies WebProbeResult;          }           const body = yield* collectBodyPreview(response.stream);          return {            status,            contentType,            location,            body,          } satisfies WebProbeResult;        }),      ),      Effect.timeoutOption(DEFAULT_WEB_PORT_PROBE_TIMEOUT_MS),      Effect.flatMap(        Option.match({          onNone: () =>            Effect.fail(              new WebPortInspectionError({                port,                host,                detail: "HTTP probe timed out.",              }),            ),          onSome: Effect.succeed,        }),      ),      Effect.mapError((error) =>        Schema.is(WebPortInspectionError)(error)          ? error          : new WebPortInspectionError({              port,              host,              detail: "Failed to execute HTTP probe request.",              cause: error,            }),      ),    );  });   const inspect: WebPortInspectorShape["inspect"] = Effect.fn("process.inspectWebPort")(function* (    port: number,  ) {    if (!Number.isInteger(port) || port <= 0 || port > 65_535) {      return yield* new WebPortInspectionError({        port,        host: "127.0.0.1",        detail: "Port must be an integer between 1 and 65535.",      });    }     const ipv4Result = yield* probeWebPortOnHost(port, "127.0.0.1").pipe(Effect.exit);    if (ipv4Result._tag === "Success" && isLikelyWebProbe(ipv4Result.value)) {      return true;    }     const ipv6Result = yield* probeWebPortOnHost(port, "::1").pipe(Effect.exit);    if (ipv6Result._tag === "Success" && isLikelyWebProbe(ipv6Result.value)) {      return true;    }     if (ipv4Result._tag === "Success" || ipv6Result._tag === "Success") {      return false;    }     if (ipv6Result._tag === "Failure") {      return yield* Effect.failCause(ipv6Result.cause);    }     return yield* Effect.failCause(ipv4Result.cause);  });   return {    inspect,  } satisfies WebPortInspectorShape;}); export const WebPortInspectorLive = Layer.effect(WebPortInspector, makeWebPortInspector);