/** * Whether a T3 Code server is currently running against a data directory. * * A maintained copy of the parts of `apps/server/src/serverRuntimeState.ts` that * host scripts need: that package exposes no importable surface to `scripts/`, * the same reason `./projection-tables.ts` exists. Only the fields read here are * modelled, so a server that adds a field stays readable. */// @effect-diagnostics nodeBuiltinImport:off - the sync probe runs inside a// synchronous SQLite transaction, where the platform layer is not available.import * as NodeFS from "node:fs";import * as NodePath from "node:path";import * as Effect from "effect/Effect";import * as Option from "effect/Option"; /** The two state directories `deriveServerPaths` can select. */const STATE_DIRS = ["dev", "userdata"] as const; /** * The runtime-state file is removed by a release finalizer, so a server killed * with SIGKILL — or one that crashed — leaves it behind. Signal 0 runs the * permission and existence checks without delivering a signal, which is what * distinguishes "still running" from "left this here on the way out". * * PIDs are reused eventually, so a false positive is possible in principle. For * a guard on a destructive local-dev command that errs the safe way: the worst * case is being told to stop a server that is already stopped. */const isPidLive = (pid: number): boolean => {  // `process.kill` reads non-positive pids as signal-group targets rather than  // process lookups — 0 signals the caller's own group, -1 every permitted  // process — so neither throws and both would report "live" unconditionally.  // The schema rejects those, and this repeats the check so the invariant  // travels with the code that depends on it.  if (!Number.isSafeInteger(pid) || pid <= 0) {    return false;  }  try {    process.kill(pid, 0);    return true;  } catch (cause) {    // EPERM means the process exists but belongs to another user. An    // out-of-range pid throws a TypeError instead, which has no errno.    return typeof cause === "object" && cause !== null && "code" in cause      ? cause.code === "EPERM"      : false;  }}; /** * The pid of a live server whose state file sits in one directory. * * Synchronous because its main caller runs inside `seedDevDatabase`'s open * SQLite transaction, where nothing can await. Applies one rule everywhere: a * positive live pid counts, anything unparseable does not — a malformed or * half-written file says nothing about liveness, and treating it as "a server * is up" would block seeding with no way to clear it. */function findPidInStateDir(baseDir: string, stateDir: string): number | undefined {  let raw: string;  try {    raw = NodeFS.readFileSync(NodePath.join(baseDir, stateDir, "server-runtime.json"), "utf8");  } catch {    return undefined;  }  try {    const parsed: unknown = JSON.parse(raw);    const pid: unknown = (parsed as { pid?: unknown } | null)?.pid;    return typeof pid === "number" && isPidLive(pid) ? pid : undefined;  } catch {    return undefined;  }} /** * The pid of a live server under `baseDir`, if any. * * `stateDir` scopes the probe to one state directory when the caller has * already resolved which database it is about to touch — a server using only * the *other* directory's database is not a conflict and must not block it. * Omitted, both directories count, for callers guarding the base as a whole. */export function findRunningServerPidSync(baseDir: string, stateDir?: string): number | undefined {  for (const candidate of stateDir === undefined ? STATE_DIRS : [stateDir]) {    const pid = findPidInStateDir(baseDir, candidate);    if (pid !== undefined) {      return pid;    }  }  return undefined;} /** {@link findRunningServerPidSync} for Effect callers. */export const findRunningServerPid = (  baseDir: string,  stateDir?: string,): Effect.Effect<Option.Option<number>> =>  Effect.sync(() => Option.fromNullishOr(findRunningServerPidSync(baseDir, stateDir)));