@sshkeda/task 0.0.0-stage → 1.0.0

package/src/lib/kill-leftover-processes/internal/mark-run-processes.ts

@@ -0,0 +1,367 @@
+import { dlopen, FFIType } from "bun:ffi";
+import type { FFIFunction } from "bun:ffi";
+
+import { Effect, FileSystem } from "effect";
+import type { PlatformError } from "effect";
+import { SecureRandom } from "effect/crypto";
+
+import { ProcRunMarkerUnreadable, SystemLibraryNotLoaded } from "../../../shared/process-errors.ts";
+import {
+  availableParallelism,
+  RUN_MARKERS_VARIABLE_NAME,
+} from "../../../shared/read-environment-config.ts";
+import { RunMarker } from "../../../shared/run-marker.ts";
+import { nullWhenProcessGoneOrHidden } from "./list-linux-processes-from-proc.ts";
+
+const MACOS_SYSTEM_LIBRARY_PATH = "/usr/lib/libSystem.B.dylib";
+const LINUX_C_LIBRARY_PATH = "libc.so.6";
+const PROC_DIRECTORY_PATH = "/proc";
+const LINUX_PIPE_LINK_PREFIX = "pipe:";
+
+const SUPERVISED_RUN_MARKER_FILE_DESCRIPTOR = 3;
+
+const CTL_KERN = 1;
+const KERN_ARGMAX = 8;
+const KERN_PROCARGS2 = 49;
+const PROC_PIDLISTFDS = 1;
+const PROC_PIDFDPIPEINFO = 6;
+const PROX_FDTYPE_PIPE = 6;
+const PROC_FDINFO_BYTES = 8;
+const PROC_FDINFO_TYPE_OFFSET = 4;
+const PIPE_FDINFO_BYTES = 184;
+const PIPE_FDINFO_HANDLE_OFFSET = 160;
+const LISTED_FILE_DESCRIPTOR_LIMIT = 4096;
+const PIPE_READ_END = 0;
+const PIPE_WRITE_END = 1;
+const PIPE_END_COUNT = 2;
+const NO_FLAVOR_ARGUMENT = 0n;
+const ARGUMENT_MAXIMUM_NAME = [CTL_KERN, KERN_ARGMAX];
+const TOKEN_READ_CHUNK_BYTES = 4096;
+
+const isMarkedPlatform = process.platform === "darwin" || process.platform === "linux";
+
+const PIPE_SYMBOLS = {
+  pipe: { args: [FFIType.ptr], returns: FFIType.i32 },
+  close: { args: [FFIType.i32], returns: FFIType.i32 },
+  read: { args: [FFIType.i32, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+  write: { args: [FFIType.i32, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+} as const satisfies Record<string, FFIFunction>;
+
+const MACOS_PROCESS_SYMBOLS = {
+  proc_pidinfo: {
+    args: [FFIType.i32, FFIType.i32, FFIType.u64, FFIType.ptr, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  proc_pidfdinfo: {
+    args: [FFIType.i32, FFIType.i32, FFIType.i32, FFIType.ptr, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  sysctl: {
+    args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u64],
+    returns: FFIType.i32,
+  },
+} as const satisfies Record<string, FFIFunction>;
+
+const openLibrary = <Symbols extends Record<string, FFIFunction>>(
+  libraryPath: string,
+  symbols: Symbols,
+) =>
+  Effect.acquireRelease(
+    Effect.try({
+      try: () => dlopen(libraryPath, symbols),
+      catch: (cause) => new SystemLibraryNotLoaded({ taskName: null, libraryPath, cause }),
+    }),
+    (library) =>
+      Effect.sync(() => {
+        library.close();
+      }),
+  ).pipe(Effect.map((library) => library.symbols));
+
+const openMacOsLibrary = openLibrary(MACOS_SYSTEM_LIBRARY_PATH, {
+  ...PIPE_SYMBOLS,
+  ...MACOS_PROCESS_SYMBOLS,
+});
+
+const openPipeLibrary =
+  process.platform === "darwin"
+    ? openMacOsLibrary
+    : openLibrary(LINUX_C_LIBRARY_PATH, PIPE_SYMBOLS);
+
+const readMacOsPipeHandle = (
+  symbols: Effect.Success<typeof openMacOsLibrary>,
+  processId: number,
+  fileDescriptor: number,
+) => {
+  const pipeInformation = new Uint8Array(PIPE_FDINFO_BYTES);
+  const filled = symbols.proc_pidfdinfo(
+    processId,
+    fileDescriptor,
+    PROC_PIDFDPIPEINFO,
+    pipeInformation,
+    PIPE_FDINFO_BYTES,
+  );
+  return filled === PIPE_FDINFO_BYTES
+    ? String(new DataView(pipeInformation.buffer).getBigUint64(PIPE_FDINFO_HANDLE_OFFSET, true))
+    : null;
+};
+
+const readProcFileUnlessGone = <Success>(
+  filePath: string,
+  readProcFile: (filePath: string) => Effect.Effect<Success, PlatformError.PlatformError>,
+) =>
+  nullWhenProcessGoneOrHidden(readProcFile(filePath), Effect.void).pipe(
+    Effect.mapError((cause) => new ProcRunMarkerUnreadable({ taskName: null, filePath, cause })),
+  );
+
+const readLinuxPipeLink = (
+  fileSystem: FileSystem.FileSystem,
+  processId: number,
+  fileDescriptor: string,
+) =>
+  readProcFileUnlessGone(
+    `${PROC_DIRECTORY_PATH}/${processId}/fd/${fileDescriptor}`,
+    fileSystem.readLink,
+  ).pipe(Effect.map((link) => (link?.startsWith(LINUX_PIPE_LINK_PREFIX) === true ? link : null)));
+
+const readOwnPipeIdentity = (fileDescriptor: number) =>
+  process.platform === "darwin"
+    ? Effect.scoped(
+        openMacOsLibrary.pipe(
+          Effect.map((symbols) => readMacOsPipeHandle(symbols, process.pid, fileDescriptor)),
+        ),
+      )
+    : FileSystem.FileSystem.use((fileSystem) =>
+        readLinuxPipeLink(fileSystem, process.pid, String(fileDescriptor)),
+      );
+
+const markerOf = (fileDescriptor: number, tokens: readonly string[]) => {
+  const token = tokens.at(-1);
+  return token === undefined
+    ? null
+    : RunMarker.make({ fileDescriptor, token, environmentValue: tokens.join(" ") });
+};
+
+export const createRunMarker = (inheritedTokens: readonly string[]) =>
+  isMarkedPlatform
+    ? Effect.scoped(
+        Effect.gen(function* () {
+          const secureRandom = yield* SecureRandom.SecureRandom;
+          const tokens = [...inheritedTokens, yield* secureRandom.uuidV4()];
+          const symbols = yield* openPipeLibrary;
+          const pipeEnds = new Int32Array(PIPE_END_COUNT);
+          if (symbols.pipe(pipeEnds) !== 0) {
+            return null;
+          }
+          const readEnd = pipeEnds[PIPE_READ_END] ?? -1;
+          const writeEnd = pipeEnds[PIPE_WRITE_END] ?? -1;
+          const tokenBytes = new TextEncoder().encode(tokens.join(" "));
+          const written = Number(symbols.write(writeEnd, tokenBytes, tokenBytes.byteLength));
+          symbols.close(writeEnd);
+          if (written !== tokenBytes.byteLength) {
+            symbols.close(readEnd);
+            return null;
+          }
+          return markerOf(readEnd, tokens);
+        }),
+      )
+    : Effect.succeed(null);
+
+const readUntilTheEnd = (
+  symbols: Effect.Success<typeof openPipeLibrary>,
+  fileDescriptor: number,
+  readSoFar = "",
+): string | null => {
+  const chunk = new Uint8Array(TOKEN_READ_CHUNK_BYTES);
+  const filled = Number(symbols.read(fileDescriptor, chunk, chunk.byteLength));
+  if (filled < 0) {
+    return null;
+  }
+  return filled > 0
+    ? readUntilTheEnd(
+        symbols,
+        fileDescriptor,
+        readSoFar + new TextDecoder().decode(chunk.subarray(0, filled)),
+      )
+    : readSoFar;
+};
+
+export const adoptSupervisorRunMarker = isMarkedPlatform
+  ? Effect.scoped(
+      Effect.gen(function* () {
+        if ((yield* readOwnPipeIdentity(SUPERVISED_RUN_MARKER_FILE_DESCRIPTOR)) === null) {
+          return null;
+        }
+        const symbols = yield* openPipeLibrary;
+        const tokens = readUntilTheEnd(symbols, SUPERVISED_RUN_MARKER_FILE_DESCRIPTOR);
+        if (tokens === null) {
+          return yield* new ProcRunMarkerUnreadable({
+            taskName: null,
+            filePath: `/dev/fd/${SUPERVISED_RUN_MARKER_FILE_DESCRIPTOR}`,
+            cause: "read failed",
+          });
+        }
+        return markerOf(
+          SUPERVISED_RUN_MARKER_FILE_DESCRIPTOR,
+          tokens.split(" ").filter((token) => token !== ""),
+        );
+      }),
+    )
+  : Effect.succeed(null);
+
+const holdsToken = (environment: Uint8Array, token: string) => {
+  const variablePrefix = `${RUN_MARKERS_VARIABLE_NAME}=`;
+  const mentionsToken = Buffer.from(
+    environment.buffer,
+    environment.byteOffset,
+    environment.byteLength,
+  ).includes(token, "latin1");
+  return (
+    mentionsToken &&
+    new TextDecoder("latin1")
+      .decode(environment)
+      .split("\0")
+      .some(
+        (entry) =>
+          entry.startsWith(variablePrefix) &&
+          entry.slice(variablePrefix.length).split(" ").includes(token),
+      )
+  );
+};
+
+const macOsHoldsPipe = (
+  symbols: Effect.Success<typeof openMacOsLibrary>,
+  fileDescriptors: Uint8Array,
+  processId: number,
+  pipeIdentity: string,
+) => {
+  const filled = symbols.proc_pidinfo(
+    processId,
+    PROC_PIDLISTFDS,
+    NO_FLAVOR_ARGUMENT,
+    fileDescriptors,
+    fileDescriptors.byteLength,
+  );
+  const fields = new DataView(fileDescriptors.buffer);
+  return Array.from(
+    { length: Math.max(filled, 0) / PROC_FDINFO_BYTES },
+    (_unused, index) => index * PROC_FDINFO_BYTES,
+  ).some(
+    (offset) =>
+      fields.getUint32(offset + PROC_FDINFO_TYPE_OFFSET, true) === PROX_FDTYPE_PIPE &&
+      readMacOsPipeHandle(symbols, processId, fields.getInt32(offset, true)) === pipeIdentity,
+  );
+};
+
+const readArgumentMaximum = (symbols: Effect.Success<typeof openMacOsLibrary>) => {
+  const value = new Int32Array(1);
+  const valueSize = new BigUint64Array([BigInt(value.byteLength)]);
+  const name = Int32Array.from(ARGUMENT_MAXIMUM_NAME);
+  return symbols.sysctl(name, name.length, value, valueSize, null, 0) === 0 ? (value[0] ?? 0) : 0;
+};
+
+const macOsEnvironmentHoldsToken = (
+  symbols: Effect.Success<typeof openMacOsLibrary>,
+  processArguments: Uint8Array,
+  processId: number,
+  token: string,
+) => {
+  const valueSize = new BigUint64Array([BigInt(processArguments.byteLength)]);
+  const name = Int32Array.from([CTL_KERN, KERN_PROCARGS2, processId]);
+  return (
+    symbols.sysctl(name, name.length, processArguments, valueSize, null, 0) === 0 &&
+    holdsToken(processArguments.subarray(0, Number(valueSize[0])), token)
+  );
+};
+
+const findMacOsMarkedProcessIds = (
+  marker: typeof RunMarker.Type,
+  candidateProcessIds: readonly number[],
+) =>
+  Effect.scoped(
+    openMacOsLibrary.pipe(
+      Effect.map((symbols) => {
+        const pipeIdentity = readMacOsPipeHandle(symbols, process.pid, marker.fileDescriptor);
+        const fileDescriptors = new Uint8Array(PROC_FDINFO_BYTES * LISTED_FILE_DESCRIPTOR_LIMIT);
+        const processArguments = new Uint8Array(readArgumentMaximum(symbols));
+        return candidateProcessIds.filter(
+          (processId) =>
+            (pipeIdentity !== null &&
+              macOsHoldsPipe(symbols, fileDescriptors, processId, pipeIdentity)) ||
+            macOsEnvironmentHoldsToken(symbols, processArguments, processId, marker.token),
+        );
+      }),
+    ),
+  );
+
+const linuxHoldsPipe = (
+  fileSystem: FileSystem.FileSystem,
+  processId: number,
+  pipeIdentity: string,
+) =>
+  readProcFileUnlessGone(`${PROC_DIRECTORY_PATH}/${processId}/fd`, (directoryPath) =>
+    fileSystem.readDirectory(directoryPath),
+  ).pipe(
+    Effect.flatMap((fileDescriptors) =>
+      Effect.forEach(fileDescriptors ?? [], (fileDescriptor) =>
+        readLinuxPipeLink(fileSystem, processId, fileDescriptor),
+      ),
+    ),
+    Effect.map((links) => links.includes(pipeIdentity)),
+  );
+
+const linuxEnvironmentHoldsToken = (
+  fileSystem: FileSystem.FileSystem,
+  processId: number,
+  token: string,
+) =>
+  readProcFileUnlessGone(`${PROC_DIRECTORY_PATH}/${processId}/environ`, fileSystem.readFile).pipe(
+    Effect.map((environment) => environment !== null && holdsToken(environment, token)),
+  );
+
+const findLinuxMarkedProcessIds = (
+  marker: typeof RunMarker.Type,
+  candidateProcessIds: readonly number[],
+) =>
+  Effect.gen(function* () {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const pipeIdentity = yield* readLinuxPipeLink(
+      fileSystem,
+      process.pid,
+      String(marker.fileDescriptor),
+    );
+    const holdsMarkerPipe = (processId: number) =>
+      pipeIdentity === null
+        ? Effect.succeed(false)
+        : linuxHoldsPipe(fileSystem, processId, pipeIdentity);
+    return yield* Effect.filter(
+      candidateProcessIds,
+      (processId) =>
+        Effect.gen(function* () {
+          return (
+            (yield* linuxEnvironmentHoldsToken(fileSystem, processId, marker.token)) ||
+            (yield* holdsMarkerPipe(processId))
+          );
+        }),
+      { concurrency: yield* availableParallelism },
+    );
+  });
+
+export const findMarkedProcessIds = (
+  marker: typeof RunMarker.Type | null,
+  candidateProcessIds: Iterable<number>,
+) => {
+  const runProcessIds = new Set([process.pid, process.ppid]);
+  const otherProcessIds = [...candidateProcessIds].filter(
+    (processId) => !runProcessIds.has(processId),
+  );
+  if (marker === null) {
+    return Effect.succeed(new Set<number>());
+  }
+  return Effect.gen(function* () {
+    return new Set(
+      process.platform === "darwin"
+        ? yield* findMacOsMarkedProcessIds(marker, otherProcessIds)
+        : yield* findLinuxMarkedProcessIds(marker, otherProcessIds),
+    );
+  });
+};

package/src/lib/kill-leftover-processes/internal/process-cleanup-errors.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+
+import { TASK_ERROR_FIELDS } from "../../../shared/error-fields.ts";
+
+export class ProcessNotKillable extends Schema.TaggedError<ProcessNotKillable>()(
+  "ProcessNotKillable",
+  {
+    ...TASK_ERROR_FIELDS,
+    processId: Schema.Int,
+    command: Schema.String,
+    ownerTaskName: Schema.NullOr(Schema.String),
+  },
+) {
+  public override get message() {
+    return `could not kill ${this.processId} (${this.command}), started by ${this.ownerTaskName === null ? "no known task" : `"${this.ownerTaskName}"`}, because the signal returned EPERM`;
+  }
+}

package/src/lib/kill-leftover-processes/internal/send-signal.ts

@@ -0,0 +1,32 @@
+import { Effect, Predicate } from "effect";
+
+import { ProcessNotSignaled } from "../../../shared/process-errors.ts";
+import { isStillListedAs } from "./list-processes.ts";
+
+export const sendSignal = (
+  taskName: string | null,
+  processId: number,
+  signal: ProcessNotSignaled["signal"],
+) =>
+  Effect.try(() => process.kill(processId, signal)).pipe(
+    Effect.as("sent" as const),
+    Effect.catchTag("UnknownError", (error) => {
+      const code = Predicate.hasProperty(error.cause, "code") ? error.cause.code : undefined;
+      const processIsGoneOrNotOurs = code === "ESRCH" || code === "EPERM";
+      return processIsGoneOrNotOurs ? Effect.succeed<"EPERM" | "ESRCH">(code) : Effect.fail(error);
+    }),
+    Effect.mapError((cause) => new ProcessNotSignaled({ taskName, processId, signal, cause })),
+  );
+
+export const signalUnlessReplaced = (
+  taskName: string | null,
+  listed: Parameters<typeof isStillListedAs>[1],
+  signal: ProcessNotSignaled["signal"],
+) =>
+  isStillListedAs(taskName, listed).pipe(
+    Effect.flatMap((isTheListedProcess) =>
+      isTheListedProcess
+        ? sendSignal(taskName, listed.processId, signal)
+        : Effect.succeed("ESRCH" as const),
+    ),
+  );

package/src/lib/kill-leftover-processes/internal/signal-run-processes.ts

@@ -0,0 +1,48 @@
+import { Effect } from "effect";
+
+import type { ProcessNotSignaled } from "../../../shared/process-errors.ts";
+import type { RunMarker } from "../../../shared/run-marker.ts";
+import { findDescendantProcessIds, findSessionProcessIds } from "./find-process-ids.ts";
+import { listProcesses } from "./list-processes.ts";
+import { findMarkedProcessIds } from "./mark-run-processes.ts";
+import { signalUnlessReplaced } from "./send-signal.ts";
+import { findStartedGroupWitness } from "./started-process-groups.ts";
+import type { startedProcessGroup } from "./started-process-groups.ts";
+
+export const signalRunProcesses = Effect.fn("signalRunProcesses")(function* (
+  run: {
+    readonly sessionId: number;
+    readonly descendantsOfProcessId: number | null;
+    readonly startedProcessGroups: ReadonlyMap<number, ReturnType<typeof startedProcessGroup>>;
+    readonly runMarker: typeof RunMarker.Type | null;
+  },
+  signal: Exclude<ProcessNotSignaled["signal"], 0>,
+  listProcessesNow: typeof listProcesses = listProcesses,
+) {
+  const listedProcesses = yield* listProcessesNow(null);
+  const startedProcessGroupIds = new Set(
+    [...run.startedProcessGroups].flatMap(([processGroupId, startedGroup]) =>
+      findStartedGroupWitness(listedProcesses, processGroupId, startedGroup) === null
+        ? []
+        : [processGroupId],
+    ),
+  );
+  const processIds = new Set([
+    ...findSessionProcessIds(listedProcesses, run.sessionId),
+    ...(run.descendantsOfProcessId === null
+      ? []
+      : findDescendantProcessIds(listedProcesses, [run.descendantsOfProcessId]).slice(1)),
+    ...(yield* findMarkedProcessIds(run.runMarker, listedProcesses.keys())),
+    ...[...listedProcesses]
+      .filter(([, listedProcess]) => startedProcessGroupIds.has(listedProcess.processGroupId))
+      .map(([processId]) => processId),
+  ]);
+  yield* Effect.forEach(
+    [...processIds].flatMap((processId) => {
+      const listedProcess = listedProcesses.get(processId);
+      return listedProcess?.hasEnded === false ? [{ ...listedProcess, processId }] : [];
+    }),
+    (listedProcess) => signalUnlessReplaced(null, listedProcess, signal),
+    { discard: true },
+  );
+});

package/src/lib/kill-leftover-processes/internal/started-process-groups.ts

@@ -0,0 +1,107 @@
+import { Effect } from "effect";
+
+import { listProcesses } from "./list-processes.ts";
+import type { isStillListedAs } from "./list-processes.ts";
+import { sendSignal } from "./send-signal.ts";
+
+export const startedProcessGroup = (
+  taskName: string,
+  leaderStartTime: string | null,
+  latestMemberStartTimeAtLeaderExit: string | null,
+) => ({ taskName, leaderStartTime, latestMemberStartTimeAtLeaderExit });
+
+export const recordLeaderExit = (
+  startedProcessGroups: Map<number, ReturnType<typeof startedProcessGroup>>,
+  processId: number,
+  latestMemberStartTime: string | null,
+) => {
+  const startedGroup = startedProcessGroups.get(processId);
+  if (startedGroup === undefined) {
+    return;
+  }
+  if (latestMemberStartTime === null) {
+    startedProcessGroups.delete(processId);
+  } else {
+    startedProcessGroups.set(
+      processId,
+      startedProcessGroup(
+        startedGroup.taskName,
+        startedGroup.leaderStartTime,
+        latestMemberStartTime,
+      ),
+    );
+  }
+};
+
+const MICROSECONDS_PER_SECOND = 1_000_000n;
+
+const orderOfStartTime = (startTime: string) => {
+  const [seconds = "0", microseconds] = startTime.split(".");
+  return microseconds === undefined
+    ? BigInt(seconds)
+    : BigInt(seconds) * MICROSECONDS_PER_SECOND + BigInt(microseconds);
+};
+
+const findLatestMemberStartTime = (
+  listedProcesses: Effect.Success<ReturnType<typeof listProcesses>>,
+  processGroupId: number,
+) =>
+  [...listedProcesses.values()]
+    .filter(
+      (listedProcess) => listedProcess.processGroupId === processGroupId && !listedProcess.hasEnded,
+    )
+    .map((listedProcess) => listedProcess.startTime)
+    .toSorted((left, right) => Number(orderOfStartTime(left) - orderOfStartTime(right)))
+    .at(-1) ?? null;
+
+export const findStartedGroupWitness = (
+  listedProcesses: Effect.Success<ReturnType<typeof listProcesses>>,
+  processGroupId: number,
+  startedGroup: Omit<ReturnType<typeof startedProcessGroup>, "taskName">,
+): Parameters<typeof isStillListedAs>[1] | null => {
+  const { leaderStartTime, latestMemberStartTimeAtLeaderExit } = startedGroup;
+  if (latestMemberStartTimeAtLeaderExit === null) {
+    const leader = listedProcesses.get(processGroupId);
+    const isTheLeaderTaskStarted =
+      leader?.processGroupId === processGroupId && leader.startTime === leaderStartTime;
+    return isTheLeaderTaskStarted
+      ? { processId: processGroupId, processGroupId, startTime: leader.startTime }
+      : null;
+  }
+  const witness = [...listedProcesses].find(
+    ([, listedProcess]) =>
+      listedProcess.processGroupId === processGroupId &&
+      !listedProcess.hasEnded &&
+      orderOfStartTime(listedProcess.startTime) <=
+        orderOfStartTime(latestMemberStartTimeAtLeaderExit) &&
+      (leaderStartTime === null ||
+        orderOfStartTime(listedProcess.startTime) >= orderOfStartTime(leaderStartTime)),
+  );
+  return witness === undefined
+    ? null
+    : { processId: witness[0], processGroupId, startTime: witness[1].startTime };
+};
+
+export const findStartedGroupWitnessNow = (
+  taskName: string | null,
+  processGroupId: number,
+  startedGroup: Omit<ReturnType<typeof startedProcessGroup>, "taskName">,
+) =>
+  listProcesses(taskName).pipe(
+    Effect.map((listedProcesses) =>
+      findStartedGroupWitness(listedProcesses, processGroupId, startedGroup),
+    ),
+  );
+
+export const readLatestMemberStartTime = (taskName: string | null, processGroupId: number) =>
+  sendSignal(taskName, -processGroupId, 0).pipe(
+    Effect.flatMap((result) =>
+      result === "ESRCH"
+        ? Effect.succeed(null)
+        : listProcesses(taskName).pipe(
+            Effect.map((listedProcesses) =>
+              findLatestMemberStartTime(listedProcesses, processGroupId),
+            ),
+          ),
+    ),
+  );

package/src/lib/main-thread/index.ts

@@ -0,0 +1,3 @@
+export { StopStateLive } from "./shared/provide-stop-state.ts";
+export { exitCodeOfTheRun, MainThreadLive } from "./internal/run-main-thread.ts";
+export { runRootTaskFiber } from "./internal/run-root-task-fiber.ts";

package/src/lib/main-thread/internal/listen-for-stop-requests.ts

@@ -0,0 +1,102 @@
+import { Deferred, Duration, Effect, Layer, Option, Stream } from "effect";
+import type { Queue } from "effect";
+
+import { findUserLocationInStack } from "../../../shared/find-user-locations-in-stack-traces.ts";
+import { TASK_TRACE_LABEL_PREFIX } from "../../../shared/names-from-package-json.ts";
+import {
+  printLine,
+  standardErrorClosedDeferred,
+  standardErrorWriteFailedDeferred,
+} from "../../../shared/print-to-standard-error.ts";
+import {
+  laterRunCallDeferred,
+  runningRootTaskDeferred,
+} from "../../../shared/signal-run-called-twice.ts";
+import type { STOP_SIGNALS } from "../../../shared/stop-signals.ts";
+import { RunCalledTwice } from "../../../shared/task-errors.ts";
+import { StopRequested } from "../shared/main-thread-errors.ts";
+import { RunRootTaskConfig } from "../shared/provide-run-root-task-config.ts";
+import { StopState } from "../shared/provide-stop-state.ts";
+
+const STOPPING_LINES = {
+  SIGINT: "stopping, press ctrl-c again to force",
+  SIGTERM: "stopping, send SIGTERM or press ctrl-c again to force",
+} as const;
+
+const GRACE_AFTER_STANDARD_ERROR_CLOSED = Duration.seconds(1);
+
+const requestStopOnSignal = Effect.fn("requestStopOnSignal")(function* (
+  signal: (typeof STOP_SIGNALS)[number],
+) {
+  yield* Effect.annotateCurrentSpan(`${TASK_TRACE_LABEL_PREFIX}.signal`, signal);
+  const shutdown = yield* StopState;
+  if (signal === "SIGHUP") {
+    return yield* shutdown.forceStop(new StopRequested({ signal }));
+  }
+  yield* Effect.gen(function* () {
+    if (yield* shutdown.requestStop(signal)) {
+      yield* printLine("Info", STOPPING_LINES[signal]);
+    }
+  }).pipe(shutdown.holdTaskLogsDuring);
+}, Effect.uninterruptible);
+
+export const stopRequestsLayer = (signals: Queue.Dequeue<(typeof STOP_SIGNALS)[number]>) =>
+  Layer.effectDiscard(
+    Effect.gen(function* () {
+      yield* Stream.fromQueue(signals).pipe(
+        Stream.runForEach(requestStopOnSignal),
+        Effect.interruptible,
+        Effect.forkScoped,
+      );
+      const shutdown = yield* StopState;
+      yield* Deferred.await(standardErrorWriteFailedDeferred).pipe(
+        Effect.flatMap(shutdown.forceStop),
+        Effect.interruptible,
+        Effect.forkScoped,
+      );
+      yield* Deferred.await(standardErrorClosedDeferred).pipe(
+        Effect.andThen(shutdown.isStopping),
+        Effect.flatMap((isStopping) =>
+          isStopping ? Effect.void : Effect.asVoid(shutdown.requestStop("SIGPIPE")),
+        ),
+        Effect.andThen(
+          shutdown.awaitForcedStop.pipe(Effect.timeoutOption(GRACE_AFTER_STANDARD_ERROR_CLOSED)),
+        ),
+        Effect.flatMap((forcedStop) =>
+          Option.isSome(forcedStop)
+            ? Effect.void
+            : shutdown.forceStop(new StopRequested({ signal: "SIGPIPE" })),
+        ),
+        Effect.interruptible,
+        Effect.forkScoped,
+      );
+    }),
+  );
+
+export const runCalledTwiceLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    const shutdown = yield* StopState;
+    yield* RunRootTaskConfig;
+    yield* Effect.all([
+      Deferred.await(runningRootTaskDeferred),
+      Deferred.await(laterRunCallDeferred),
+    ]).pipe(
+      Effect.map(
+        ([runningCall, laterCall]) =>
+          new RunCalledTwice({
+            runningRootTaskName: runningCall.rootTaskName,
+            runningRootTaskLocation:
+              runningCall.stack === undefined
+                ? undefined
+                : findUserLocationInStack(runningCall.stack),
+            laterRootTaskName: laterCall.rootTaskName,
+            location:
+              laterCall.stack === undefined ? undefined : findUserLocationInStack(laterCall.stack),
+          }),
+      ),
+      Effect.flatMap(shutdown.recordFirstFailure),
+      Effect.interruptible,
+      Effect.forkScoped,
+    );
+  }),
+);