import * as Duration from "effect/Duration";import * as Effect from "effect/Effect";import * as FileSystem from "effect/FileSystem";import * as Path from "effect/Path";import * as Schema from "effect/Schema";import * as Semaphore from "effect/Semaphore"; import * as ProcessRunner from "../processRunner.ts"; /** * A pinned runtime is an exact `t3@<version>` npm-installed into * <baseDir>/runtime/versions/<version>. The boot service points its systemd * unit here, and server self-update installs the target version here before * switching over — never `npx t3`, whose cache is ephemeral and whose * registry fetch at boot would make startup depend on the network. */ const PINNED_RUNTIME_DIR = "runtime";const PINNED_RUNTIME_INSTALL_TIMEOUT = Duration.minutes(10);// Boot-service setup and remote self-update share this module but can be// constructed in separate layers. Serialize the complete check/install/// sentinel transaction across all callers in this process.const pinnedRuntimeInstallLock = Semaphore.makeUnsafe(1); export interface PinnedRuntimePaths {  readonly versionDir: string;  readonly entryPath: string;  readonly sentinelPath: string;} export function pinnedRuntimePaths(  path: Path.Path,  baseDir: string,  version: string,): PinnedRuntimePaths {  const versionDir = path.join(baseDir, PINNED_RUNTIME_DIR, "versions", version);  return {    versionDir,    entryPath: path.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"),    sentinelPath: path.join(versionDir, ".install-complete"),  };} export class PinnedRuntimeInstallError extends Schema.TaggedErrorClass<PinnedRuntimeInstallError>()(  "PinnedRuntimeInstallError",  {    step: Schema.String,    exitCode: Schema.optional(Schema.Number),    stdoutLength: Schema.optional(Schema.Number),    stderrLength: Schema.optional(Schema.Number),    cause: Schema.optional(Schema.Defect()),  },) {  override get message(): string {    return this.exitCode === undefined      ? `Pinned runtime install failed while ${this.step}.`      : `Pinned runtime install failed while ${this.step} (exit code ${this.exitCode}).`;  }} /** * Installs `t3@<version>` into the pinned runtime directory unless a complete * install is already there, and returns its paths. The sentinel is written * only after npm exits 0; checking the entry file alone is not enough — npm * extracts files before running native builds (node-pty), so a killed * install leaves a plausible-looking but broken tree behind. */export const ensurePinnedRuntimeInstalled = Effect.fn("cloud.pinned_runtime.ensure_installed")(  function* (input: {    readonly baseDir: string;    readonly version: string;    readonly fs: FileSystem.FileSystem;    readonly path: Path.Path;    readonly runner: ProcessRunner.ProcessRunner["Service"];  }) {    const { fs, runner } = input;    const paths = pinnedRuntimePaths(input.path, input.baseDir, input.version);     return yield* pinnedRuntimeInstallLock.withPermit(      Effect.gen(function* () {        const alreadyPinned = yield* Effect.all([          fs.exists(paths.sentinelPath),          fs.exists(paths.entryPath),        ]).pipe(          Effect.map(([sentinelExists, entryExists]) => sentinelExists && entryExists),          Effect.mapError(            (cause) =>              new PinnedRuntimeInstallError({ step: "checking the pinned runtime", cause }),          ),        );        if (alreadyPinned) {          return paths;        }         yield* fs.remove(paths.versionDir, { recursive: true, force: true }).pipe(          Effect.andThen(fs.makeDirectory(paths.versionDir, { recursive: true })),          Effect.mapError(            (cause) =>              new PinnedRuntimeInstallError({                step: "preparing the pinned runtime directory",                cause,              }),          ),        );         const installStep = "installing the pinned t3 runtime (this can take a few minutes)";        yield* runner          .run({            command: "npm",            args: [              "install",              "--prefix",              paths.versionDir,              "--no-fund",              "--no-audit",              `t3@${input.version}`,            ],            // Native deps (node-pty) can compile from source on slow boxes; the            // ProcessRunner default of 60s would kill a healthy install.            timeout: PINNED_RUNTIME_INSTALL_TIMEOUT,          })          .pipe(            Effect.mapError((cause) => new PinnedRuntimeInstallError({ step: installStep, cause })),            Effect.filterOrFail(              (result) => result.code === 0,              (result) =>                new PinnedRuntimeInstallError({                  step: installStep,                  exitCode: Number(result.code),                  stdoutLength: result.stdout.length,                  stderrLength: result.stderr.length,                }),            ),            Effect.tapError(() =>              fs.remove(paths.versionDir, { recursive: true, force: true }).pipe(Effect.ignore),            ),          );         yield* fs          .writeFileString(paths.sentinelPath, `${input.version}\n`)          .pipe(            Effect.mapError(              (cause) =>                new PinnedRuntimeInstallError({ step: "recording the completed install", cause }),            ),          );         return paths;      }),    );  },); /** Removes one pinned runtime while holding the same process-wide lock used * by install/check/sentinel work, so cleanup cannot race another caller that * is materializing or reusing the runtime tree. */export const removePinnedRuntimeInstallation = Effect.fn("cloud.pinned_runtime.remove")(  function* (input: {    readonly baseDir: string;    readonly version: string;    readonly fs: FileSystem.FileSystem;    readonly path: Path.Path;  }) {    const paths = pinnedRuntimePaths(input.path, input.baseDir, input.version);    yield* pinnedRuntimeInstallLock.withPermit(      input.fs        .remove(paths.versionDir, { recursive: true, force: true })        .pipe(          Effect.mapError(            (cause) =>              new PinnedRuntimeInstallError({ step: "removing the pinned runtime", cause }),          ),        ),    );  },);