import * as OS from "node:os"; import * as Context from "effect/Context";import * as Effect from "effect/Effect";import * as FileSystem from "effect/FileSystem";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Schema from "effect/Schema";import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; import { collectUint8StreamText } from "../../stream/collectUint8StreamText.ts"; interface ResolveServerEnvironmentLabelInput {  readonly cwdBaseName: string;  readonly platform?: NodeJS.Platform;  readonly hostname?: string | null;} interface ServerEnvironmentLabelCommandResult {  readonly stdout: string;  readonly exitCode: number;} interface ServerEnvironmentLabelCommandRunnerShape {  readonly run: (    command: string,    args: readonly string[],  ) => Effect.Effect<ServerEnvironmentLabelCommandResult, ServerEnvironmentLabelCommandError>;} export class ServerEnvironmentLabelCommandError extends Schema.TaggedErrorClass<ServerEnvironmentLabelCommandError>()(  "ServerEnvironmentLabelCommandError",  {    command: Schema.String,    args: Schema.Array(Schema.String),    message: Schema.String,    cause: Schema.optional(Schema.Defect),  },) {} export class ServerEnvironmentLabelCommandRunner extends Context.Service<  ServerEnvironmentLabelCommandRunner,  ServerEnvironmentLabelCommandRunnerShape>()("t3/environment/Layers/ServerEnvironmentLabel/CommandRunner") {} export const ServerEnvironmentLabelCommandRunnerLive = Layer.effect(  ServerEnvironmentLabelCommandRunner,  Effect.gen(function* () {    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;     return ServerEnvironmentLabelCommandRunner.of({      run: (command, args) =>        Effect.scoped(          Effect.gen(function* () {            const child = yield* spawner.spawn(              ChildProcess.make(command, [...args], {                shell: process.platform === "win32",              }),            );            const [stdout, , exitCode] = yield* Effect.all(              [                collectUint8StreamText({ stream: child.stdout }),                collectUint8StreamText({ stream: child.stderr }),                child.exitCode,              ],              { concurrency: "unbounded" },            );             return {              stdout: stdout.text,              exitCode: Number(exitCode),            };          }).pipe(            Effect.mapError(              (cause) =>                new ServerEnvironmentLabelCommandError({                  command,                  args: [...args],                  message: `Failed to run friendly host label command: ${command}.`,                  cause,                }),            ),          ),        ),    });  }),); function normalizeLabel(value: string | null | undefined): Option.Option<string> {  const trimmed = value?.trim();  return trimmed && trimmed.length > 0 ? Option.some(trimmed) : Option.none();} function parseMachineInfoValue(raw: string, key: string): Option.Option<string> {  for (const line of raw.split(/\r?\n/g)) {    const trimmed = line.trim();    if (trimmed.length === 0 || trimmed.startsWith("#") || !trimmed.startsWith(`${key}=`)) {      continue;    }    const value = trimmed.slice(key.length + 1).trim();    if (      (value.startsWith('"') && value.endsWith('"')) ||      (value.startsWith("'") && value.endsWith("'"))    ) {      return normalizeLabel(value.slice(1, -1));    }    return normalizeLabel(value);  }  return Option.none();} const readLinuxMachineInfo = Effect.fn("readLinuxMachineInfo")(function* () {  const fileSystem = yield* FileSystem.FileSystem;  const exists = yield* fileSystem    .exists("/etc/machine-info")    .pipe(Effect.orElseSucceed(() => false));  if (!exists) {    return Option.none();  }   const raw = yield* fileSystem.readFileString("/etc/machine-info").pipe(Effect.option);   return Option.flatMap(raw, normalizeLabel);}); const runFriendlyLabelCommand = Effect.fn("runFriendlyLabelCommand")(function* (  command: string,  args: readonly string[],) {  const commandRunner = yield* ServerEnvironmentLabelCommandRunner;  const result = yield* commandRunner.run(command, args).pipe(Effect.option);   if (Option.isNone(result) || result.value.exitCode !== 0) {    return Option.none();  }   return normalizeLabel(result.value.stdout);}); const resolveFriendlyHostLabel = Effect.fn("resolveFriendlyHostLabel")(function* (  platform: NodeJS.Platform,) {  if (platform === "darwin") {    return yield* runFriendlyLabelCommand("scutil", ["--get", "ComputerName"]);  }   if (platform === "linux") {    const machineInfo = yield* readLinuxMachineInfo();    if (Option.isSome(machineInfo)) {      const prettyHostname = parseMachineInfoValue(machineInfo.value, "PRETTY_HOSTNAME");      if (Option.isSome(prettyHostname)) {        return prettyHostname;      }    }     return yield* runFriendlyLabelCommand("hostnamectl", ["--pretty"]);  }   return Option.none();}); export const resolveServerEnvironmentLabel = Effect.fn("resolveServerEnvironmentLabel")(function* (  input: ResolveServerEnvironmentLabelInput,) {  const platform = input.platform ?? process.platform;  const friendlyHostLabel = yield* resolveFriendlyHostLabel(platform);  if (Option.isSome(friendlyHostLabel)) {    return friendlyHostLabel.value;  }   const hostname = normalizeLabel(input.hostname ?? OS.hostname());  if (Option.isSome(hostname)) {    return hostname.value;  }   return Option.getOrElse(normalizeLabel(input.cwdBaseName), () => "T3 environment");});