@sshkeda/task 0.0.0-stage → 1.0.1

package/src/lib/main-thread/shared/read-package-json.ts

@@ -0,0 +1,149 @@
+import { Effect, FileSystem, Formatter, Option, Predicate, Schema, Struct } from "effect";
+import type { PlatformError } from "effect";
+
+import { dieOnInvariantFailure } from "../../../shared/invariant-errors.ts";
+import { describeCauseMessage } from "../../../shared/report-errors.ts";
+import {
+  PackageJsonFieldInvalid,
+  PackageJsonNameBlank,
+  PackageJsonNameInvalid,
+  PackageJsonNameNotString,
+  PackageJsonNotJson,
+  PackageJsonNotObject,
+  PackageJsonUnreadable,
+  PackageJsonWithoutName,
+} from "./package-json-errors.ts";
+
+const DependencyVersions = Schema.Record(Schema.String, Schema.String).annotate({
+  expected: "an object of strings",
+});
+
+const CHECKED_PACKAGE_JSON_FIELDS = Schema.Struct({
+  version: Schema.String.annotate({ expected: "a string" }),
+  dependencies: DependencyVersions,
+  devDependencies: DependencyVersions,
+  peerDependencies: DependencyVersions,
+  optionalDependencies: DependencyVersions,
+});
+
+const PackageJsonObject = Schema.Record(Schema.String, Schema.Unknown);
+
+const PackageJsonFields = CHECKED_PACKAGE_JSON_FIELDS.mapFields(Struct.map(Schema.optional));
+
+const NON_BLANK_TEXT = /\S/u;
+
+const isPackageName = Schema.is(
+  Schema.String.check(Schema.isPattern(/^(?:@[^./][^/]*\/)?[^./][^/]*$/u)),
+);
+
+export const readPackageJsonText = (packageJsonFilePath: string) =>
+  FileSystem.FileSystem.use((fileSystem) => fileSystem.readFileString(packageJsonFilePath));
+
+export const toPackageJsonUnreadable =
+  (packageJsonFilePath: string) => (cause: PlatformError.PlatformError) =>
+    new PackageJsonUnreadable({ filePath: packageJsonFilePath, cause });
+
+export const parsePackageJsonObject = (packageJsonFilePath: string, packageJsonText: string) =>
+  Effect.gen(function* () {
+    const parsed = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(
+      packageJsonText,
+    ).pipe(
+      Effect.catchTag("SchemaError", () =>
+        Effect.try({
+          try: () => Bun.JSONC.parse(packageJsonText),
+          catch: (cause) =>
+            new PackageJsonNotJson({
+              filePath: packageJsonFilePath,
+              parserMessage: describeCauseMessage(cause),
+            }),
+        }).pipe(
+          Effect.andThen(
+            Effect.fail(
+              new PackageJsonNotJson({ filePath: packageJsonFilePath, parserMessage: null }),
+            ),
+          ),
+        ),
+      ),
+    );
+    return yield* Schema.decodeUnknownEffect(PackageJsonObject)(parsed).pipe(
+      Effect.mapError(
+        () =>
+          new PackageJsonNotObject({
+            filePath: packageJsonFilePath,
+            valueText: Formatter.format(parsed),
+          }),
+      ),
+    );
+  });
+
+export const decodePackageJsonName = (
+  packageJsonFilePath: string,
+  packageJsonObject: typeof PackageJsonObject.Type,
+) => {
+  const { name } = packageJsonObject;
+  if (name === undefined) {
+    return Effect.succeedNone;
+  }
+  if (!Predicate.isString(name)) {
+    return Effect.fail(
+      new PackageJsonNameNotString({
+        filePath: packageJsonFilePath,
+        nameText: Formatter.format(name),
+      }),
+    );
+  }
+  return NON_BLANK_TEXT.test(name)
+    ? Effect.succeedSome(name)
+    : Effect.fail(new PackageJsonNameBlank({ filePath: packageJsonFilePath, packageName: name }));
+};
+
+export const decodePackageJsonText = (packageJsonFilePath: string) => (packageJsonText: string) =>
+  Effect.gen(function* () {
+    const packageJsonObject = yield* parsePackageJsonObject(packageJsonFilePath, packageJsonText);
+    const name = yield* decodePackageJsonName(packageJsonFilePath, packageJsonObject);
+    for (const [fieldName, fieldSchema] of Object.entries(CHECKED_PACKAGE_JSON_FIELDS.fields)) {
+      const value = packageJsonObject[fieldName];
+      const isInvalidFieldValue = value !== undefined && !Schema.is(fieldSchema)(value);
+      if (isInvalidFieldValue) {
+        return yield* new PackageJsonFieldInvalid({
+          filePath: packageJsonFilePath,
+          fieldName,
+          valueText: Formatter.format(value),
+          expected: yield* Effect.fromNullishOr(
+            Schema.resolveAnnotations(fieldSchema)?.expected,
+          ).pipe(
+            dieOnInvariantFailure(
+              "package.json decoding",
+              "each checked field names what it expects",
+            ),
+          ),
+        });
+      }
+    }
+    const fields = yield* Schema.decodeEffect(PackageJsonFields)(packageJsonObject).pipe(
+      dieOnInvariantFailure("package.json decoding", "fields that passed their checks decode"),
+    );
+    return { ...fields, name: Option.getOrUndefined(name) };
+  });
+
+export const readPackageJson = (packageJsonDirectoryPath: string) => {
+  const packageJsonFilePath = `${packageJsonDirectoryPath}/package.json`;
+  return readPackageJsonText(packageJsonFilePath).pipe(
+    Effect.mapError(toPackageJsonUnreadable(packageJsonFilePath)),
+    Effect.flatMap(decodePackageJsonText(packageJsonFilePath)),
+    Effect.flatMap(({ name, ...packageJson }) =>
+      Effect.gen(function* () {
+        if (name === undefined) {
+          return yield* new PackageJsonWithoutName({ filePath: packageJsonFilePath });
+        }
+        if (!isPackageName(name)) {
+          return yield* new PackageJsonNameInvalid({
+            filePath: packageJsonFilePath,
+            packageName: name,
+          });
+        }
+        return { ...packageJson, name };
+      }),
+    ),
+  );
+};

package/src/lib/main-thread/shared/report-task-failure.ts

@@ -0,0 +1,31 @@
+import { Cause, Effect, Predicate } from "effect";
+
+import { formatCauseLines } from "../../../shared/format-error-lines.ts";
+import { TASK_TRACE_LABEL_PREFIX } from "../../../shared/names-from-package-json.ts";
+import { printTaskLines } from "../../../shared/print-to-standard-error.ts";
+import { reportCause } from "../../../shared/report-cause.ts";
+import { StopState } from "./provide-stop-state.ts";
+
+export const reportFailure = (failure: Error) => reportCause(Cause.fail(failure)).failures;
+
+export const reportTaskFailure = Effect.fn("reportTaskFailure")(function* (
+  taskName: string,
+  cause: Parameters<StopState["Service"]["recordTaskFailureCause"]>[1],
+) {
+  const shutdown = yield* StopState;
+  yield* shutdown.recordTaskFailureCause(taskName, cause);
+  const errorLines = formatCauseLines(cause, taskName);
+  if (cause.reasons.length > 0) {
+    yield* printTaskLines("Error", taskName, errorLines);
+  }
+  const failures = cause.reasons.filter(Cause.isFailReason).map((reason) => reason.error);
+  for (const failure of failures) {
+    yield* shutdown.recordPrintedFailure(failure);
+  }
+  const details = failures
+    .map((failure) => (Predicate.hasProperty(failure, "details") ? failure.details : undefined))
+    .filter((detail) => Predicate.isString(detail));
+  yield* Effect.logInfo(`failed: ${details.length === 0 ? errorLines : details.join("\n")}`).pipe(
+    Effect.annotateLogs(`${TASK_TRACE_LABEL_PREFIX}.task`, taskName),
+  );
+}, Effect.uninterruptible);

package/src/lib/preload-rewritten-imports-into-each-worker/index.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+
+import { loadRewrittenImports } from "./internal/load-rewritten-imports.ts";
+
+Effect.runSync(loadRewrittenImports);

package/src/lib/preload-rewritten-imports-into-each-worker/internal/load-rewritten-imports.ts

@@ -0,0 +1,34 @@
+import { workerData } from "node:worker_threads";
+
+import { Effect, Schema } from "effect";
+
+import { RewrittenModuleUnloadable } from "../../../shared/module-graph-errors.ts";
+import { WorkerData } from "../../../shared/rpc.ts";
+
+export const loadRewrittenImports = Effect.gen(function* () {
+  const rewrittenFiles = new Map(
+    Object.entries((yield* Schema.decodeUnknownEffect(WorkerData)(workerData)).rewrittenFiles),
+  );
+
+  Bun.plugin({
+    name: "task rewritten imports",
+    target: "bun",
+    setup: (build) => {
+      build.onLoad(
+        {
+          filter: new RegExp(
+            `^(?:${[...rewrittenFiles.keys()].map((path) => RegExp.escape(path)).join("|")})$`,
+            "u",
+          ),
+        },
+        (loaded) => {
+          const rewrittenFile = rewrittenFiles.get(loaded.path);
+          if (rewrittenFile === undefined) {
+            throw new RewrittenModuleUnloadable({ filePath: loaded.path });
+          }
+          return rewrittenFile;
+        },
+      );
+    },
+  });
+});

package/src/lib/supervise-the-run/index.ts

@@ -0,0 +1,15 @@
+import { Ref } from "effect";
+
+import { supervisorProcessId, supervisorRunMarker } from "./internal/watch-the-supervisor.ts";
+
+export { isRootTaskFileThere } from "./internal/check-root-task-file.ts";
+export { reportReady } from "./internal/report-ready.ts";
+export {
+  processGroupsSharedWithTheSupervisor,
+  shareProcessGroups,
+} from "./internal/share-process-groups.ts";
+export { superviseRun } from "./internal/supervise-run.ts";
+
+export const readSupervisorProcessId = Ref.get(supervisorProcessId);
+
+export const readSupervisorRunMarker = Ref.get(supervisorRunMarker);

package/src/lib/supervise-the-run/internal/adopt-orphans-on-linux.ts

@@ -0,0 +1,73 @@
+import { dlopen, FFIType } from "bun:ffi";
+
+import { Effect, Stream } from "effect";
+
+import { listenToSignals } from "../../../shared/stop-signals.ts";
+
+const C_LIBRARY_PATH = "libc.so.6";
+const PR_SET_CHILD_SUBREAPER = 36;
+const PRCTL_ENABLE = 1n;
+const PRCTL_UNUSED_ARGUMENT = 0n;
+const P_ALL = 0;
+const WNOHANG = 1;
+const WEXITED = 4;
+const WNOWAIT = 0x01_00_00_00;
+const SIGINFO_BYTES = 128;
+const SIGINFO_PROCESS_ID_OFFSET = 16;
+
+const openCLibrary = Effect.acquireRelease(
+  Effect.sync(() =>
+    dlopen(C_LIBRARY_PATH, {
+      prctl: {
+        args: [FFIType.i32, FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u64],
+        returns: FFIType.i32,
+      },
+      waitid: { args: [FFIType.i32, FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+      waitpid: { args: [FFIType.i32, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    }),
+  ),
+  (library) =>
+    Effect.sync(() => {
+      library.close();
+    }),
+).pipe(Effect.map((library) => library.symbols));
+
+const reapExitedOrphans = (
+  symbols: Effect.Success<typeof openCLibrary>,
+  runProcessId: number,
+): void => {
+  const information = new Uint8Array(SIGINFO_BYTES);
+  const peeked = symbols.waitid(P_ALL, 0, information, WEXITED | WNOHANG | WNOWAIT);
+  const processId = new DataView(information.buffer).getInt32(SIGINFO_PROCESS_ID_OFFSET, true);
+  const isExitedOrphan = peeked === 0 && processId !== 0 && processId !== runProcessId;
+  if (isExitedOrphan) {
+    symbols.waitpid(processId, null, 0);
+    reapExitedOrphans(symbols, runProcessId);
+  }
+};
+
+export const adoptOrphans = Effect.gen(function* () {
+  if (process.platform !== "linux") {
+    return () => Effect.void;
+  }
+  const symbols = yield* openCLibrary;
+  symbols.prctl(
+    PR_SET_CHILD_SUBREAPER,
+    PRCTL_ENABLE,
+    PRCTL_UNUSED_ARGUMENT,
+    PRCTL_UNUSED_ARGUMENT,
+    PRCTL_UNUSED_ARGUMENT,
+  );
+  const childSignals = yield* listenToSignals(["SIGCHLD"]);
+  return (runProcessId: number) =>
+    Stream.fromQueue(childSignals).pipe(
+      Stream.runForEach(() =>
+        Effect.sync(() => {
+          reapExitedOrphans(symbols, runProcessId);
+        }),
+      ),
+      Effect.interruptible,
+      Effect.forkScoped,
+      Effect.asVoid,
+    );
+});

package/src/lib/supervise-the-run/internal/check-root-task-file.ts

@@ -0,0 +1,8 @@
+import { Effect, FileSystem } from "effect";
+
+import { RootTaskFileNotChecked } from "../../../shared/task-errors.ts";
+
+export const isRootTaskFileThere = FileSystem.FileSystem.pipe(
+  Effect.flatMap((fileSystem) => fileSystem.exists(Bun.main)),
+  Effect.mapError((cause) => new RootTaskFileNotChecked({ filePath: Bun.main, cause })),
+);

package/src/lib/supervise-the-run/internal/report-ready.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+
+import { completeOnceSent } from "../../../shared/complete-discarded-calls-once-sent.ts";
+import { callTheSupervisor } from "./talk-to-the-supervisor.ts";
+
+export const reportReady = Effect.scope.pipe(
+  Effect.flatMap((scope) =>
+    callTheSupervisor((supervisor) =>
+      supervisor.ReportReady(undefined, { discard: true }).pipe(completeOnceSent(scope)),
+    ),
+  ),
+);

package/src/lib/supervise-the-run/internal/share-process-groups.ts

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+
+import type { startedProcessGroup } from "../../kill-leftover-processes/index.ts";
+import { callTheSupervisor } from "./talk-to-the-supervisor.ts";
+
+export const processGroupsSharedWithTheSupervisor = new Map<
+  number,
+  ReturnType<typeof startedProcessGroup>
+>();
+
+export const shareProcessGroups = (processGroupIds: Iterable<number>) =>
+  callTheSupervisor((supervisor) =>
+    Effect.forEach(
+      processGroupIds,
+      (processGroupId) =>
+        supervisor.ShareProcessGroup(
+          {
+            processGroupId,
+            startedGroup: processGroupsSharedWithTheSupervisor.get(processGroupId) ?? null,
+          },
+          { discard: true },
+        ),
+      { discard: true },
+    ),
+  );

package/src/lib/supervise-the-run/internal/start-watching-the-supervisor.ts

@@ -0,0 +1,6 @@
+import * as BunServices from "@effect/platform-bun/BunServices";
+import { Effect } from "effect";
+
+import { watchSupervisor } from "./watch-the-supervisor.ts";
+
+Effect.runFork(watchSupervisor.pipe(Effect.provide(BunServices.layer)));

package/src/lib/supervise-the-run/internal/supervise-run.ts

@@ -0,0 +1,155 @@
+import * as BunSocketServer from "@effect/platform-bun/BunSocketServer";
+import { Deferred, Duration, Effect, Exit, FileSystem, Path, Predicate, Ref, Stream } from "effect";
+import type { Queue } from "effect";
+import { RpcServer } from "effect/rpc";
+import { SocketServer } from "effect/socket";
+
+import { TASK_TRACE_LABEL_PREFIX } from "../../../shared/names-from-package-json.ts";
+import { SupervisorSocketNotOpened } from "../../../shared/process-errors.ts";
+import {
+  inheritedEnvironment,
+  inheritedRunMarkers,
+  RUN_MARKERS_VARIABLE_NAME,
+  supervisedRunCommand,
+} from "../../../shared/read-environment-config.ts";
+import { saveStandardStreamFlags } from "../../../shared/save-standard-stream-flags.ts";
+import { listenToSignals } from "../../../shared/stop-signals.ts";
+import type { STOP_SIGNALS } from "../../../shared/stop-signals.ts";
+import { createRunMarker, signalRunProcesses } from "../../kill-leftover-processes/index.ts";
+import type { startedProcessGroup } from "../../kill-leftover-processes/index.ts";
+import { adoptOrphans } from "./adopt-orphans-on-linux.ts";
+import { provideSupervisorRpcSerialization, SupervisorRpcs } from "./talk-to-the-supervisor.ts";
+import { WATCH_THE_SUPERVISOR_FLAG } from "./watch-the-supervisor.ts";
+
+const FORCED_STOP_GRACE_SECONDS = 5;
+
+const FORCED_STOP_GRACE = Duration.seconds(FORCED_STOP_GRACE_SECONDS);
+
+const SUPERVISOR_SOCKET_FILE_NAME = "supervisor.sock";
+
+const serveTheRun = Effect.fn("serveTheRun")(
+  function* (
+    ready: Deferred.Deferred<void>,
+    startedProcessGroups: Map<number, ReturnType<typeof startedProcessGroup>>,
+  ) {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const socketPath = yield* fileSystem
+      .makeTempDirectoryScoped({ prefix: `${TASK_TRACE_LABEL_PREFIX}-supervisor-` })
+      .pipe(
+        Effect.map((socketDirectoryPath) =>
+          path.join(socketDirectoryPath, SUPERVISOR_SOCKET_FILE_NAME),
+        ),
+      );
+    const socketServer = yield* BunSocketServer.make({ path: socketPath });
+    const handlers = yield* SupervisorRpcs.toHandlers({
+      ReportReady: () => Deferred.done(ready, Exit.void).pipe(Effect.asVoid),
+      ShareProcessGroup: (shared) =>
+        Effect.sync(() => {
+          if (shared.startedGroup === null) {
+            startedProcessGroups.delete(shared.processGroupId);
+          } else {
+            startedProcessGroups.set(shared.processGroupId, shared.startedGroup);
+          }
+        }),
+    });
+    yield* RpcServer.make(SupervisorRpcs, { disableTracing: true }).pipe(
+      Effect.provideContext(handlers),
+      Effect.provideServiceEffect(RpcServer.Protocol, RpcServer.makeProtocolSocketServer),
+      Effect.provideService(SocketServer.SocketServer, socketServer),
+      provideSupervisorRpcSerialization,
+      Effect.interruptible,
+      Effect.forkScoped,
+    );
+    return socketPath;
+  },
+  Effect.mapError((cause) => new SupervisorSocketNotOpened({ cause })),
+);
+
+export const superviseRun = Effect.fn("superviseRun")(function* (
+  stopSignals: Queue.Dequeue<(typeof STOP_SIGNALS)[number]>,
+) {
+  const reapAdoptedOrphans = yield* adoptOrphans;
+  const exited = yield* Deferred.make<NodeJS.Signals | number>();
+  const ready = yield* Deferred.make<void>();
+  const startedProcessGroups = new Map<number, ReturnType<typeof startedProcessGroup>>();
+  const command = yield* supervisedRunCommand(
+    WATCH_THE_SUPERVISOR_FLAG,
+    yield* serveTheRun(ready, startedProcessGroups),
+  );
+  const environment = yield* inheritedEnvironment;
+  const runMarker = yield* createRunMarker(yield* inheritedRunMarkers);
+  const restoreStandardStreamFlags = yield* saveStandardStreamFlags;
+  const child = yield* Effect.sync(() =>
+    Bun.spawn(command, {
+      detached: true,
+      stdio: [
+        "inherit",
+        "inherit",
+        "inherit",
+        ...(runMarker === null ? [] : [runMarker.fileDescriptor]),
+      ],
+      env:
+        runMarker === null
+          ? environment
+          : Object.fromEntries(
+              Object.entries(environment).filter(([name]) => name !== RUN_MARKERS_VARIABLE_NAME),
+            ),
+      onExit: (exitedChild, exitCode) => {
+        Deferred.doneUnsafe(exited, Exit.succeed(exitedChild.signalCode ?? exitCode ?? 1));
+      },
+    }),
+  );
+  yield* restoreStandardStreamFlags;
+  yield* reapAdoptedOrphans(child.pid);
+  const run = {
+    sessionId: child.pid,
+    descendantsOfProcessId: process.platform === "linux" ? process.pid : null,
+    startedProcessGroups,
+    runMarker,
+  };
+  const forced = yield* Deferred.make<void>();
+  const stopCount = yield* Ref.make(0);
+  yield* Stream.fromQueue(stopSignals).pipe(
+    Stream.runForEach((signal) =>
+      Ref.updateAndGet(stopCount, (count) => count + 1).pipe(
+        Effect.flatMap((count) => {
+          const forcesTheStop = signal === "SIGHUP" || count > 1;
+          const forward = Effect.sync(() => {
+            child.kill(signal);
+          });
+          return forcesTheStop
+            ? forward.pipe(Effect.andThen(Deferred.done(forced, Exit.void)), Effect.asVoid)
+            : Deferred.await(ready).pipe(Effect.andThen(forward), Effect.forkScoped, Effect.asVoid);
+        }),
+      ),
+    ),
+    Effect.interruptible,
+    Effect.forkScoped,
+  );
+  const jobControlSignals = yield* listenToSignals(["SIGTSTP", "SIGCONT"]);
+  yield* Stream.fromQueue(jobControlSignals).pipe(
+    Stream.runForEach((signal) =>
+      signal === "SIGTSTP"
+        ? signalRunProcesses(run, "SIGSTOP").pipe(
+            Effect.andThen(Effect.sync(() => process.kill(process.pid, "SIGSTOP"))),
+          )
+        : signalRunProcesses(run, "SIGCONT"),
+    ),
+    Effect.interruptible,
+    Effect.forkScoped,
+  );
+  yield* Deferred.await(exited).pipe(
+    Effect.raceFirst(
+      Deferred.await(forced).pipe(
+        Effect.andThen(Deferred.await(exited).pipe(Effect.timeoutOption(FORCED_STOP_GRACE))),
+      ),
+    ),
+  );
+  const runSkippedItsCleanup =
+    (yield* Deferred.isDone(forced)) || Predicate.isString(yield* Deferred.await(exited));
+  if (runSkippedItsCleanup) {
+    yield* signalRunProcesses(run, "SIGKILL");
+  }
+  return yield* Deferred.await(exited);
+});

package/src/lib/supervise-the-run/internal/talk-to-the-supervisor.ts

@@ -0,0 +1,53 @@
+import * as BunSocket from "@effect/platform-bun/BunSocket";
+import { Deferred, Duration, Effect, Schema } from "effect";
+import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/rpc";
+import type { RpcClientError } from "effect/rpc";
+import { Socket } from "effect/socket";
+
+export const ProcessGroupShared = Schema.Struct({
+  processGroupId: Schema.Int,
+  startedGroup: Schema.NullOr(
+    Schema.Struct({
+      taskName: Schema.String,
+      leaderStartTime: Schema.NullOr(Schema.String),
+      latestMemberStartTimeAtLeaderExit: Schema.NullOr(Schema.String),
+    }),
+  ),
+});
+
+export const SupervisorRpcs = RpcGroup.make(
+  Rpc.make("ReportReady"),
+  Rpc.make("ShareProcessGroup", { payload: ProcessGroupShared }),
+);
+
+export const provideSupervisorRpcSerialization = Effect.provideService(
+  RpcSerialization.RpcSerialization,
+  RpcSerialization.ndjson,
+);
+
+export const connectToTheSupervisor = (
+  supervisorSocketPath: string,
+  onDisconnect: Effect.Effect<void>,
+) =>
+  RpcClient.make(SupervisorRpcs, { disableTracing: true }).pipe(
+    Effect.provideServiceEffect(
+      RpcClient.Protocol,
+      RpcClient.makeProtocolSocket({ pingInterval: Duration.infinity }),
+    ),
+    Effect.provideService(RpcClient.ConnectionHooks, { onConnect: Effect.void, onDisconnect }),
+    Effect.provideServiceEffect(Socket.Socket, BunSocket.makeNet({ path: supervisorSocketPath })),
+    provideSupervisorRpcSerialization,
+  );
+
+export const supervisorConnectionDeferred =
+  Deferred.makeUnsafe<Effect.Success<ReturnType<typeof connectToTheSupervisor>>>();
+
+export const callTheSupervisor = (
+  call: (
+    supervisor: Effect.Success<ReturnType<typeof connectToTheSupervisor>>,
+  ) => Effect.Effect<void, RpcClientError.RpcClientError>,
+) =>
+  Deferred.await(supervisorConnectionDeferred).pipe(
+    Effect.flatMap(call),
+    Effect.catchTag("RpcClientError", () => Effect.void),
+  );

package/src/lib/supervise-the-run/internal/watch-the-supervisor.ts

@@ -0,0 +1,61 @@
+import { Deferred, Effect, Exit, Option, Ref, Stdio, Stream } from "effect";
+
+import { formatFailureLines } from "../../../shared/format-error-lines.ts";
+import { takeSupervisorSocketPath } from "../../../shared/read-environment-config.ts";
+import type { RunMarker } from "../../../shared/run-marker.ts";
+import {
+  adoptSupervisorRunMarker,
+  signalRunProcesses,
+} from "../../kill-leftover-processes/index.ts";
+import { processGroupsSharedWithTheSupervisor } from "./share-process-groups.ts";
+import { connectToTheSupervisor, supervisorConnectionDeferred } from "./talk-to-the-supervisor.ts";
+
+export const WATCH_THE_SUPERVISOR_FLAG = `--preload=${Bun.fileURLToPath(import.meta.resolve("./start-watching-the-supervisor.ts"))}`;
+
+export const supervisorProcessId = Ref.makeUnsafe<number | null>(null);
+
+export const supervisorRunMarker = Ref.makeUnsafe<typeof RunMarker.Type | null>(null);
+
+export const watchSupervisor = Effect.gen(function* () {
+  yield* Effect.sync(() =>
+    process.execArgv.splice(process.execArgv.indexOf(WATCH_THE_SUPERVISOR_FLAG), 1),
+  );
+  const supervisorSocketPath = yield* takeSupervisorSocketPath;
+  if (Option.isNone(supervisorSocketPath)) {
+    return;
+  }
+  yield* Ref.set(supervisorProcessId, process.ppid);
+  const stdio = yield* Stdio.Stdio;
+  const printFailure = (error: Parameters<typeof formatFailureLines>[0]) =>
+    Stream.make(`${formatFailureLines(error, null)}\n`).pipe(Stream.run(stdio.stderr()));
+  const runMarker = yield* adoptSupervisorRunMarker.pipe(
+    Effect.catchTag(["ProcRunMarkerUnreadable", "SystemLibraryNotLoaded"], (error) =>
+      printFailure(error).pipe(Effect.as(null)),
+    ),
+  );
+  yield* Ref.set(supervisorRunMarker, runMarker);
+  const disconnected = yield* Deferred.make<void>();
+  const supervisor = yield* connectToTheSupervisor(
+    supervisorSocketPath.value,
+    Deferred.done(disconnected, Exit.void).pipe(Effect.asVoid),
+  );
+  yield* Deferred.succeed(supervisorConnectionDeferred, supervisor);
+  yield* Deferred.await(disconnected).pipe(
+    Effect.andThen(
+      signalRunProcesses(
+        {
+          sessionId: process.pid,
+          descendantsOfProcessId: process.pid,
+          startedProcessGroups: processGroupsSharedWithTheSupervisor,
+          runMarker,
+        },
+        "SIGKILL",
+      ),
+    ),
+    Effect.matchEffect({
+      onFailure: (error) => printFailure(error),
+      onSuccess: (success) => Effect.succeed(success),
+    }),
+    Effect.ensuring(Effect.sync(() => process.kill(process.pid, "SIGKILL"))),
+  );
+}).pipe(Effect.scoped);

package/src/lib/task/index.ts

@@ -0,0 +1,5 @@
+export { make, Task } from "./internal/make-tasks.ts";
+export { exec } from "./internal/run-command.ts";
+export { main } from "./internal/run-root-task.ts";
+export { all, allSettled } from "./internal/run-task-lists.ts";
+export { serve } from "./internal/use-task-services.ts";