@danieljvdm/dev-kit 0.2.0

package/src/gitignore.ts

@@ -0,0 +1,212 @@
+import { Cause, Effect, FileSystem, Path, PlatformError, Schema } from "effect";
+
+import { printStatus } from "./cli-ui.ts";
+import { observeSymbolicLink } from "./node-symbolic-link.ts";
+import { acquireProjectProcessLock } from "./project-process-lock.ts";
+
+export const CANONICAL_REPOSITORIES_DIRECTORY = ".repos";
+
+export const DEV_KIT_GITIGNORE_ENTRIES = [
+  `${CANONICAL_REPOSITORIES_DIRECTORY}/`,
+  ".dev-kit/",
+] as const;
+
+export type GitignoreOptions = {
+  readonly dryRun?: boolean;
+  readonly projectDir?: string;
+};
+
+export type GitignorePatch = {
+  readonly path: string;
+  readonly changed: boolean;
+  readonly added: ReadonlyArray<string>;
+};
+
+export class UnsafeGitignorePathError extends Schema.TaggedErrorClass<UnsafeGitignorePathError>()(
+  "UnsafeGitignorePathError",
+  {
+    path: Schema.String,
+    reason: Schema.String,
+  },
+) {
+  override get message() {
+    return `refusing to patch ${this.path}: ${this.reason}`;
+  }
+}
+
+export class GitignoreConflictError extends Schema.TaggedErrorClass<GitignoreConflictError>()(
+  "GitignoreConflictError",
+  { path: Schema.String },
+) {
+  override get message() {
+    return `${this.path} changed while dev-kit was preparing its patch; rerun the command`;
+  }
+}
+
+type PlannedGitignorePatch = GitignorePatch & {
+  readonly contents: string;
+  readonly existed: boolean;
+  readonly mode: number | undefined;
+  readonly previousContents: string;
+};
+
+const publicPatch = (patch: PlannedGitignorePatch): GitignorePatch => ({
+  path: patch.path,
+  changed: patch.changed,
+  added: patch.added,
+});
+
+export const patchGitignoreContents = (
+  current: string,
+): { readonly contents: string; readonly added: ReadonlyArray<string> } => {
+  const lines = current.split(/\r?\n/);
+  const added = DEV_KIT_GITIGNORE_ENTRIES.filter((entry) => !lines.includes(entry));
+  if (added.length === 0) return { contents: current, added };
+
+  const newline = current.includes("\r\n") ? "\r\n" : "\n";
+  const separator = current.length === 0
+    ? ""
+    : current.endsWith(`${newline}${newline}`)
+      ? ""
+      : current.endsWith(newline)
+        ? newline
+        : `${newline}${newline}`;
+  const block = ["# dev-kit managed paths", ...added].join(newline);
+  return {
+    contents: `${current}${separator}${block}${newline}`,
+    added,
+  };
+};
+
+const planGitignorePatch = Effect.fn("planGitignorePatch")(function* (
+  projectDir: string,
+): Effect.fn.Return<
+  PlannedGitignorePatch,
+  UnsafeGitignorePathError | PlatformError.PlatformError,
+  FileSystem.FileSystem | Path.Path
+> {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const gitignorePath = path.join(projectDir, ".gitignore");
+  const observation = yield* observeSymbolicLink(gitignorePath);
+  if (observation.kind === "symlink") {
+    return yield* new UnsafeGitignorePathError({
+      path: gitignorePath,
+      reason: "the file is a symlink",
+    });
+  }
+
+  let current = "";
+  let mode: number | undefined;
+  if (observation.kind !== "missing") {
+    const info = yield* fs.stat(gitignorePath);
+    if (info.type !== "File") {
+      return yield* new UnsafeGitignorePathError({
+        path: gitignorePath,
+        reason: "the path is not a regular file",
+      });
+    }
+    current = yield* fs.readFileString(gitignorePath);
+    mode = info.mode & 0o777;
+  }
+
+  const patch = patchGitignoreContents(current);
+  return {
+    path: gitignorePath,
+    changed: patch.added.length > 0,
+    added: patch.added,
+    contents: patch.contents,
+    existed: observation.kind !== "missing",
+    mode,
+    previousContents: current,
+  };
+});
+
+const applyGitignorePatch = Effect.fn("applyGitignorePatch")(function* (
+  projectDir: string,
+  patch: PlannedGitignorePatch,
+) {
+  if (!patch.changed) return;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const tempDir = yield* fs.makeTempDirectoryScoped({
+    directory: path.join(projectDir, ".dev-kit"),
+    prefix: "gitignore-",
+  });
+  const staged = path.join(tempDir, "next.gitignore");
+  const backup = path.join(tempDir, "previous.gitignore");
+  yield* fs.writeFileString(staged, patch.contents, { mode: patch.mode ?? 0o666 });
+
+  const currentObservation = yield* observeSymbolicLink(patch.path);
+  const changed = patch.existed
+    ? currentObservation.kind !== "not-symlink" ||
+      (yield* fs.readFileString(patch.path)) !== patch.previousContents
+    : currentObservation.kind !== "missing";
+  if (changed) {
+    return yield* new GitignoreConflictError({ path: patch.path });
+  }
+
+  let backedUp = false;
+  let installed = false;
+  const rollback = Effect.gen(function* () {
+    if (installed) {
+      yield* fs.remove(patch.path, { force: true });
+    }
+    if (backedUp) {
+      yield* fs.rename(backup, patch.path);
+    }
+  });
+  const apply = Effect.gen(function* () {
+    if (patch.existed) {
+      yield* fs.rename(patch.path, backup);
+      backedUp = true;
+    }
+    yield* fs.rename(staged, patch.path);
+    installed = true;
+  });
+
+  yield* Effect.uninterruptible(
+    apply.pipe(
+      Effect.catchCause((applyCause) =>
+        rollback.pipe(
+          Effect.catchCause((rollbackCause) =>
+            Effect.failCause(Cause.combine(applyCause, rollbackCause)),
+          ),
+          Effect.andThen(Effect.failCause(applyCause)),
+        ),
+      ),
+    ),
+  );
+});
+
+export const patchProjectGitignore = Effect.fn("patchProjectGitignore")(function* (
+  options: GitignoreOptions = {},
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const projectDir = yield* fs.realPath(path.resolve(options.projectDir ?? "."));
+
+  if (options.dryRun) {
+    const patch = yield* planGitignorePatch(projectDir);
+    yield* printStatus(
+      patch.changed ? "plan" : "success",
+      patch.changed ? "Would update .gitignore" : ".gitignore up to date",
+      patch.changed ? `add ${patch.added.join(", ")}` : undefined,
+    );
+    return publicPatch(patch);
+  }
+
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      yield* acquireProjectProcessLock(projectDir);
+      const patch = yield* planGitignorePatch(projectDir);
+      yield* applyGitignorePatch(projectDir, patch);
+      yield* printStatus(
+        "success",
+        patch.changed ? "Updated .gitignore" : ".gitignore up to date",
+        patch.changed ? `added ${patch.added.join(", ")}` : undefined,
+      );
+      return publicPatch(patch);
+    }),
+  );
+});

package/src/index.ts

@@ -0,0 +1,98 @@
+export {
+  type DevKitManifest,
+  DevKitManifestSchema,
+  type EffectSourceSetup,
+  EffectSourceSetupSchema,
+  type EffectTsgoSetup,
+  EffectTsgoSetupSchema,
+  type HarnessTarget,
+  TargetConfigSchema,
+} from "./manifest.ts";
+export {
+  applyEffectSourcePlan,
+  EffectSourceCheckoutError,
+  EffectSourceDependencyError,
+  type EffectSourceOptions,
+  type EffectSourcePlan,
+  planEffectSource,
+  syncEffectSource,
+} from "./effect-source.ts";
+export {
+  CANONICAL_REPOSITORIES_DIRECTORY,
+  DEV_KIT_GITIGNORE_ENTRIES,
+  GitignoreConflictError,
+  patchGitignoreContents,
+  patchProjectGitignore,
+  type GitignoreOptions,
+  type GitignorePatch,
+  UnsafeGitignorePathError,
+} from "./gitignore.ts";
+export {
+  EFFECT_TSGO_PLUGIN_NAME,
+  EFFECT_TSGO_TYPESCRIPT_VERSION,
+  EFFECT_TSGO_VERSION,
+  EffectTsgoDependencyError,
+  InvalidEffectTsgoPackageNameError,
+  type EffectTsgoPatchOptions,
+  type EffectTsgoPatchPlan,
+  EffectTsgoPatchCommandError,
+  patchEffectTsgo,
+  planEffectTsgoPatch,
+} from "./effect-tsgo.ts";
+export {
+  ExternalSkillSourceSchema,
+  type ExternalSkillSource,
+  LockedSkillSourceSchema,
+  type LockedSkillSource,
+  SkillSourcesLockSchema,
+  type SkillSourcesLock,
+  SkillSourcesManifestSchema,
+  type SkillSourcesManifest,
+} from "./source-manifest.ts";
+export {
+  planProjectSkills,
+  printSkillPlan,
+  runProjectSkillPlan,
+  type SkillPlan,
+  type SyncOptions,
+} from "./sync.ts";
+export {
+  AppliedStateSchema,
+  DevKitLockSchema,
+  EffectSourceLockSchema,
+  EffectTsgoLockSchema,
+  ManagedSkillOutputSchema,
+  OwnershipReceiptSchema,
+  type AppliedState,
+  type DevKitLock,
+  type EffectSourceLock,
+  type EffectTsgoLock,
+  type ManagedSkillOutput,
+  type OwnershipReceipt,
+} from "./project-state.ts";
+export {
+  refreshSkillCatalog,
+  vendorExternalSkills,
+  type CatalogRefreshOptions,
+  type VendorOptions,
+} from "./vendor.ts";
+export {
+  loadSkillCatalog,
+  resolveSkillSources,
+  type CatalogSkill,
+  type ResolvedSkillSource,
+  type SkillCatalog,
+} from "./catalog.ts";
+export {
+  addCatalogSource,
+  listCatalogSources,
+  removeCatalogEntry,
+  showCatalogSource,
+  type CatalogAddOptions,
+  type CatalogCommandOptions,
+} from "./catalog-manager.ts";
+export {
+  inspectCatalogRepository,
+  type CatalogInspection,
+  type CatalogInspectOptions,
+} from "./vendor.ts";

package/src/manifest.ts

@@ -0,0 +1,133 @@
+import { Schema } from "effect";
+
+import { TYPESCRIPT_PACKAGE_NAME_PATTERN } from "./typescript-package-name.ts";
+
+export type HarnessTarget = "agents" | "claude" | "opencode";
+
+export const SyncMode = Schema.Literals(["copy", "symlink"]);
+export type SyncMode = "copy" | "symlink";
+
+export const TargetConfigSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+  mode: Schema.optional(SyncMode),
+  path: Schema.optional(Schema.String),
+});
+
+export type TargetConfig = typeof TargetConfigSchema.Type;
+
+export const EffectTsgoSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+  force: Schema.optional(Schema.Boolean),
+  typescriptPackage: Schema.optional(
+    Schema.String.check(Schema.isPattern(TYPESCRIPT_PACKAGE_NAME_PATTERN)),
+  ),
+});
+
+export type EffectTsgoSetup = typeof EffectTsgoSetupSchema.Type;
+
+export const EffectSourceSetupSchema = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean),
+  packageName: Schema.optional(
+    Schema.String.check(Schema.isPattern(TYPESCRIPT_PACKAGE_NAME_PATTERN)),
+  ),
+  path: Schema.optional(Schema.String),
+  repository: Schema.optional(Schema.String),
+});
+
+export type EffectSourceSetup = typeof EffectSourceSetupSchema.Type;
+
+export const DevKitManifestSchema = Schema.Struct({
+  $schema: Schema.optional(Schema.String),
+  include: Schema.Array(Schema.String),
+  exclude: Schema.optional(Schema.Array(Schema.String)),
+  setup: Schema.optional(
+    Schema.Struct({
+      effectSource: Schema.optional(EffectSourceSetupSchema),
+      effectTsgo: Schema.optional(EffectTsgoSetupSchema),
+    }),
+  ),
+  targets: Schema.optional(
+    Schema.Struct({
+      agents: Schema.optional(TargetConfigSchema),
+      claude: Schema.optional(TargetConfigSchema),
+      opencode: Schema.optional(TargetConfigSchema),
+    }),
+  ),
+});
+
+export type DevKitManifest = typeof DevKitManifestSchema.Type;
+
+export type NormalizedTargetConfig = {
+  readonly enabled: boolean;
+  readonly mode: SyncMode;
+  readonly path: string;
+};
+
+export type NormalizedManifest = {
+  readonly include: ReadonlyArray<string>;
+  readonly exclude: ReadonlyArray<string>;
+  readonly setup: {
+    readonly effectSource: {
+      readonly enabled: boolean;
+      readonly packageName: string;
+      readonly path: string;
+      readonly repository: string;
+    };
+    readonly effectTsgo: {
+      readonly enabled: boolean;
+      readonly force: boolean;
+      readonly typescriptPackage: string;
+    };
+  };
+  readonly targets: Readonly<Record<HarnessTarget, NormalizedTargetConfig>>;
+};
+
+const DEFAULT_TARGET_PATHS: Readonly<Record<HarnessTarget, string>> = {
+  agents: ".agents/skills",
+  claude: ".claude/skills",
+  opencode: ".opencode/skills",
+};
+
+const DEFAULT_TARGETS: Readonly<Record<HarnessTarget, NormalizedTargetConfig>> = {
+  agents: { enabled: true, mode: "copy", path: DEFAULT_TARGET_PATHS.agents },
+  claude: { enabled: false, mode: "symlink", path: DEFAULT_TARGET_PATHS.claude },
+  opencode: { enabled: false, mode: "symlink", path: DEFAULT_TARGET_PATHS.opencode },
+};
+
+export const normalizeManifest = (manifest: DevKitManifest): NormalizedManifest => {
+  const targets = {
+    ...DEFAULT_TARGETS,
+  };
+
+  for (const key of ["agents", "claude", "opencode"] as const) {
+    const override = manifest.targets?.[key];
+    if (override) {
+      targets[key] = {
+        enabled: override.enabled ?? DEFAULT_TARGETS[key].enabled,
+        mode: override.mode ?? DEFAULT_TARGETS[key].mode,
+        path: override.path ?? DEFAULT_TARGETS[key].path,
+      };
+    }
+  }
+
+  return {
+    exclude: manifest.exclude ?? [],
+    include: manifest.include,
+    setup: {
+      effectSource: {
+        enabled: manifest.setup?.effectSource?.enabled ?? false,
+        packageName: manifest.setup?.effectSource?.packageName ?? "effect",
+        path: manifest.setup?.effectSource?.path ?? ".repos/effect",
+        repository:
+          manifest.setup?.effectSource?.repository ??
+          "https://github.com/Effect-TS/effect.git",
+      },
+      effectTsgo: {
+        enabled: manifest.setup?.effectTsgo?.enabled ?? false,
+        force: manifest.setup?.effectTsgo?.force ?? false,
+        typescriptPackage: manifest.setup?.effectTsgo?.typescriptPackage ?? "typescript",
+      },
+    },
+    targets,
+  };
+};

package/src/node-symbolic-link.ts

@@ -0,0 +1,31 @@
+import { Effect, FileSystem, PlatformError } from "effect";
+
+export type SymbolicLinkObservation =
+  | { readonly kind: "missing" | "not-symlink" }
+  | { readonly kind: "symlink"; readonly target: string };
+
+// Effect beta.102's Node FileSystem adapter maps readlink(2) EINVAL to Unknown.
+// Keep that runtime-specific normalization at this narrow adapter boundary.
+const isNotSymbolicLink = (error: PlatformError.PlatformError): boolean => {
+  if (error.reason._tag !== "Unknown") return false;
+  const cause = error.reason.cause;
+  return cause instanceof Error && "code" in cause && cause.code === "EINVAL";
+};
+
+export const observeSymbolicLink = Effect.fn("observeSymbolicLink")(function* (
+  absolutePath: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  return yield* fs.readLink(absolutePath).pipe(
+    Effect.map((target): SymbolicLinkObservation => ({ kind: "symlink", target })),
+    Effect.catch((error) => {
+      if (error.reason._tag === "NotFound") {
+        return Effect.succeed<SymbolicLinkObservation>({ kind: "missing" });
+      }
+      if (isNotSymbolicLink(error)) {
+        return Effect.succeed<SymbolicLinkObservation>({ kind: "not-symlink" });
+      }
+      return Effect.fail(error);
+    }),
+  );
+});

package/src/path-digest.ts

@@ -0,0 +1,140 @@
+import { Crypto, Effect, Encoding, FileSystem, Path, PlatformError, Schema } from "effect";
+
+import { observeSymbolicLink } from "./node-symbolic-link.ts";
+
+export const DigestSchema = Schema.String.check(
+  Schema.isPattern(/^sha256:[0-9a-f]{64}$/),
+);
+export type Digest = typeof DigestSchema.Type;
+
+export type ObservedPath =
+  | { readonly kind: "missing" }
+  | { readonly kind: "file" | "directory" | "symlink"; readonly digest: Digest };
+
+export class PathInspectionError extends Schema.TaggedErrorClass<PathInspectionError>()(
+  "PathInspectionError",
+  {
+    path: Schema.String,
+    operation: Schema.String,
+    cause: Schema.Unknown,
+  },
+) {
+  override get message() {
+    return `could not ${this.operation} managed path ${this.path}`;
+  }
+}
+
+const textEncoder = new TextEncoder();
+
+const frame = (value: string | Uint8Array): Uint8Array => {
+  const bytes = typeof value === "string" ? textEncoder.encode(value) : value;
+  const framed = new Uint8Array(4 + bytes.length);
+  new DataView(framed.buffer).setUint32(0, bytes.length);
+  framed.set(bytes, 4);
+  return framed;
+};
+
+const concatenate = (chunks: ReadonlyArray<Uint8Array>): Uint8Array => {
+  const combined = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return combined;
+};
+
+const compareUtf8 = (left: string, right: string): number => {
+  const leftBytes = textEncoder.encode(left);
+  const rightBytes = textEncoder.encode(right);
+  const sharedLength = Math.min(leftBytes.length, rightBytes.length);
+  for (let index = 0; index < sharedLength; index += 1) {
+    const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return leftBytes.length - rightBytes.length;
+};
+
+const digestFrames = Effect.fn("digestPathFrames")(function* (
+  values: ReadonlyArray<string | Uint8Array>,
+) {
+  const crypto = yield* Crypto.Crypto;
+  const digest = yield* crypto.digest("SHA-256", concatenate(values.map(frame)));
+  return `sha256:${Encoding.encodeHex(digest)}`;
+});
+
+const digestFileSystemPath = Effect.fn("digestFileSystemPath")(function* (
+  absolutePath: string,
+): Effect.fn.Return<ObservedPath, PlatformError.PlatformError | PathInspectionError, FileSystem.FileSystem | Path.Path | Crypto.Crypto> {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const symbolicLink = yield* observeSymbolicLink(absolutePath);
+
+  if (symbolicLink.kind === "missing") return { kind: "missing" };
+  if (symbolicLink.kind === "symlink") {
+    return {
+      kind: "symlink",
+      digest: yield* digestFrames(["symlink-v1", symbolicLink.target]),
+    };
+  }
+
+  const info = yield* fs.stat(absolutePath).pipe(
+    Effect.catch((error) =>
+      error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
+    ),
+  );
+  if (info === undefined) return { kind: "missing" };
+
+  if (info.type === "File") {
+    return {
+      kind: "file",
+      digest: yield* digestFrames([
+        "file-v1",
+        String(info.mode & 0o777),
+        yield* fs.readFile(absolutePath),
+      ]),
+    };
+  }
+
+  if (info.type === "Directory") {
+    const entries = (yield* fs.readDirectory(absolutePath)).sort(compareUtf8);
+    const frames: Array<string | Uint8Array> = ["directory-v1"];
+    for (const entry of entries) {
+      const childPath = path.join(absolutePath, entry);
+      const child = yield* digestFileSystemPath(childPath);
+      if (child.kind === "missing") {
+        return yield* new PathInspectionError({
+          path: childPath,
+          operation: "inspect a stable directory tree",
+          cause: "path disappeared during inspection",
+        });
+      }
+      frames.push(entry, child.kind, child.digest);
+    }
+    return { kind: "directory", digest: yield* digestFrames(frames) };
+  }
+
+  return yield* new PathInspectionError({
+    path: absolutePath,
+    operation: "inspect unsupported filesystem entry",
+    cause: info.type,
+  });
+});
+
+export const observePath = Effect.fn("observeManagedPath")(function* (absolutePath: string) {
+  return yield* digestFileSystemPath(absolutePath).pipe(
+    Effect.mapError((cause) =>
+      cause instanceof PathInspectionError
+        ? cause
+        : new PathInspectionError({ path: absolutePath, operation: "inspect", cause }),
+    ),
+  );
+});
+
+export const digestText = Effect.fn("digestText")(function* (value: string) {
+  return yield* digestFrames(["text-v1", value]);
+});
+
+export const digestSymlinkTarget = Effect.fn("digestSymlinkTarget")(function* (target: string) {
+  return yield* digestFrames(["symlink-v1", target]);
+});

package/src/project-process-lock.ts

@@ -0,0 +1,76 @@
+import { Cause, Crypto, DateTime, Effect, FileSystem, Path, Schema } from "effect";
+
+import { DEV_KIT_VERSION } from "./tool-metadata.ts";
+
+export const PROJECT_PROCESS_LOCK_PATH = ".dev-kit/apply.lock";
+
+export class ProjectAlreadyLockedError extends Schema.TaggedErrorClass<ProjectAlreadyLockedError>()(
+  "ProjectAlreadyLockedError",
+  { path: Schema.String },
+) {
+  override get message() {
+    return `another dev-kit apply may be active (${this.path}); verify the owner before removing a stale lock`;
+  }
+}
+
+export const acquireProjectProcessLock = Effect.fn("acquireProjectProcessLock")(function* (
+  projectDir: string,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const crypto = yield* Crypto.Crypto;
+  const lockDir = path.join(projectDir, ...PROJECT_PROCESS_LOCK_PATH.split("/"));
+  const stateDir = path.dirname(lockDir);
+  const ownerPath = path.join(lockDir, "owner.json");
+  const token = yield* crypto.randomUUIDv7;
+  const startedAt = DateTime.formatIso(yield* DateTime.now);
+  const ownerContents = `${JSON.stringify(
+    {
+      version: 1,
+      toolVersion: DEV_KIT_VERSION,
+      token,
+      startedAt,
+    },
+    null,
+    2,
+  )}\n`;
+
+  return yield* Effect.acquireRelease(
+    Effect.gen(function* () {
+      yield* fs.makeDirectory(stateDir, { recursive: true });
+      return yield* Effect.uninterruptible(
+        Effect.gen(function* () {
+          yield* fs.makeDirectory(lockDir).pipe(
+            Effect.mapError((error) =>
+              error.reason._tag === "AlreadyExists"
+                ? new ProjectAlreadyLockedError({ path: lockDir })
+                : error,
+            ),
+          );
+          yield* fs.writeFileString(ownerPath, ownerContents).pipe(
+            Effect.catchCause((writeCause) =>
+              fs.remove(lockDir, { recursive: true, force: true }).pipe(
+                Effect.catchCause((cleanupCause) =>
+                  Effect.failCause(Cause.combine(writeCause, cleanupCause)),
+                ),
+                Effect.andThen(Effect.failCause(writeCause)),
+              ),
+            ),
+          );
+          return { lockDir, ownerContents };
+        }),
+      );
+    }),
+    ({ lockDir: acquiredLockDir, ownerContents }) =>
+      Effect.gen(function* () {
+        const currentOwner = yield* fs.readFileString(ownerPath).pipe(
+          Effect.catch((error) =>
+            error.reason._tag === "NotFound" ? Effect.void : Effect.fail(error),
+          ),
+        );
+        if (currentOwner === ownerContents) {
+          yield* fs.remove(acquiredLockDir, { recursive: true, force: true });
+        }
+      }).pipe(Effect.orDie),
+  ).pipe(Effect.map(({ lockDir }) => lockDir));
+});