}

}

async function acquirePackageLock(lockDir: string, ownerToken: string): Promise<void> {

async function acquirePackageLock(

lockDir: string,

ownerToken: string,

params: { writeOwner?: (lockDir: string, ownerToken: string) => Promise<void> } = {},

): Promise<void> {

const timeoutMs = readPositiveIntEnv("OPENCLAW_PARALLELS_PACKAGE_LOCK_TIMEOUT_MS", 30 * 60_000);

const staleMs = readPositiveIntEnv("OPENCLAW_PARALLELS_PACKAGE_LOCK_STALE_MS", 2 * 60 * 60_000);

const startedAt = Date.now();

let waitAnnouncementBudget = 1;

const consumeWaitAnnouncement = () => waitAnnouncementBudget-- > 0;

while (Date.now() - startedAt < timeoutMs) {

let createdLockDir = false;

try {

await mkdir(lockDir);

await writeLockOwner(lockDir, ownerToken);

createdLockDir = true;

await (params.writeOwner ?? writeLockOwner)(lockDir, ownerToken);

return;

} catch (error) {

if (createdLockDir) {

await rm(lockDir, { force: true, recursive: true }).catch(() => undefined);

}

if (!isErrorCode(error, "EEXIST")) {

throw error;

}

}

export const testing = {

acquirePackageLock,

removeStalePackageLock,

readLockOwner,

};

expect(existsSync(lockDir)).toBe(false);

});

it("removes a just-created package lock when owner writing fails", async () => {

const parentDir = makeTempDir(tempDirs, "openclaw-parallels-package-lock-parent-");

const lockDir = join(parentDir, "package.lock");

const error = new Error("failed to write owner");

await expect(

packageArtifactTesting.acquirePackageLock(lockDir, "owner-token", {

writeOwner: async () => {

throw error;

},

}),

).rejects.toBe(error);

expect(existsSync(lockDir)).toBe(false);

});

it("keeps JSON-mode progress off stdout", async () => {

const stdoutWrite = vi.spyOn(process.stdout, "write").mockImplementation(() => true);

const stderrWrite = vi.spyOn(process.stderr, "write").mockImplementation(() => true);