import { describe, expect, it } from "vitest";

import { isPidDefinitelyDead, shouldRemoveDeadOwnerOrExpiredLock } from "./stale-lock-file.js";

describe("stale lock file ownership", () => {

it("treats permission-denied process probes as not definitely dead", () => {

expect(

shouldRemoveDeadOwnerOrExpiredLock({

payload: {

pid: 123,

createdAt: new Date(Date.now() - 60_000).toISOString(),

},

staleMs: 10,

isPidDefinitelyDead: () => false,

}),

).toBe(false);

});

it("only removes pid-owned locks when the owner is definitely dead", () => {

expect(

shouldRemoveDeadOwnerOrExpiredLock({

payload: {

pid: 123,

createdAt: new Date(Date.now() - 60_000).toISOString(),

},

staleMs: 10,

isPidDefinitelyDead: () => true,

}),

).toBe(true);

});

it("treats invalid pids as definitely dead", () => {

expect(isPidDefinitelyDead(-1)).toBe(true);

});

});

import fs from "node:fs/promises";

import { isPidAlive as defaultIsPidAlive } from "../shared/pid-alive.js";

export type LockFileSnapshot = {

raw: string;

payload: Record<string, unknown> | null;

staleMs: number;

nowMs?: number;

isPidAlive?: (pid: number) => boolean;

isPidDefinitelyDead?: (pid: number) => boolean;

}): boolean {

const payload = readLockFileOwnerPayload(params.payload);

if (payload?.pid) {

return !(params.isPidAlive ?? defaultIsPidAlive)(payload.pid);

return (params.isPidDefinitelyDead ?? isPidDefinitelyDead)(payload.pid);

}

if (payload?.createdAt) {

const createdAt = Date.parse(payload.createdAt);

return false;

}

export function isPidDefinitelyDead(pid: number): boolean {

if (!Number.isInteger(pid) || pid <= 0) {

return true;

}

try {

process.kill(pid, 0);

return false;

} catch (err) {

return (err as NodeJS.ErrnoException).code === "ESRCH";

}

}

export async function removeLockFileIfSnapshotMatches(params: {

lockPath: string;

snapshot: LockFileSnapshot;

stale: 10,

} as const;

const deadPid = Number.MAX_SAFE_INTEGER;

const deadPid = -1;

await fs.writeFile(

lockPath,

JSON.stringify({ pid: deadPid, createdAt: new Date(Date.now() - 60_000).toISOString() }),

}

})(),

).rejects.toMatchObject({

code: FILE_LOCK_STALE_ERROR_CODE,

code: FILE_LOCK_TIMEOUT_ERROR_CODE,

});

await expect(fs.realpath(caught?.lockPath ?? "")).resolves.toBe(await fs.realpath(lockPath));

await expect(fs.readFile(lockPath, "utf8")).resolves.toContain(`"pid":${process.pid}`);

resetFileLockManagerForTest,

} from "@openclaw/fs-safe/file-lock";

import {

readLockFileOwnerPayload,

removeReportedStaleLockIfStillStale,

shouldRemoveDeadOwnerOrExpiredLock,

} from "../infra/stale-lock-file.js";

import { isPidAlive } from "../shared/pid-alive.js";

export type FileLockOptions = {

retries: {

staleMs: number;

nowMs: number;

}): Promise<boolean> {

const payload = readLockFileOwnerPayload(params.payload);

if (payload?.pid && !isPidAlive(payload.pid)) {

return true;

}

if (payload?.createdAt) {

const createdAt = Date.parse(payload.createdAt);

return !Number.isFinite(createdAt) || params.nowMs - createdAt > params.staleMs;

}

return false;

return shouldRemoveDeadOwnerOrExpiredLock({

payload: params.payload,

staleMs: params.staleMs,

nowMs: params.nowMs,

});

}

function isFileLockError(error: unknown, code: string): boolean {