pidLock.ts

import { isEnoent, isProcessAlive } from "@procni/core";
import { ProcniError } from "@procni/shared";
import { readFile, rm, writeFile } from "node:fs/promises";
import { join } from "node:path";

interface LockInfo {
  pid: number;
  port: number;
  startedAt: string;
}

function lockFilePath(projectDir: string): string {
  return join(projectDir, "procni.lock");
}

/**
 * Throws `ALREADY_RUNNING` if a live `procni dev` process already holds this
 * project's lock. A lock file whose `pid` is no longer a running process
 * (the previous `procni dev` crashed instead of shutting down cleanly) is
 * treated as stale and ignored — this is what lets `procni dev` recover on
 * its own after a crash, instead of requiring a developer to manually delete
 * a leftover lock file.
 */
export async function assertNotAlreadyRunning(projectDir: string): Promise<void> {
  const existing = await readLockIfExists(projectDir);
  if (existing && isProcessAlive(existing.pid)) {
    throw new ProcniError(
      "ALREADY_RUNNING",
      `procni dev is already running for this project (pid ${existing.pid}) at http://127.0.0.1:${existing.port}.`,
    );
  }
}

export async function writeLock(projectDir: string, info: LockInfo): Promise<void> {
  await writeFile(lockFilePath(projectDir), JSON.stringify(info), "utf8");
}

export async function releaseLock(projectDir: string): Promise<void> {
  await rm(lockFilePath(projectDir), { force: true });
}

async function readLockIfExists(projectDir: string): Promise<LockInfo | null> {
  try {
    return JSON.parse(await readFile(lockFilePath(projectDir), "utf8")) as LockInfo;
  } catch (err) {
    if (isEnoent(err)) return null;
    throw err;
  }
}