Files
hyperframes/packages/cli/src/utils/projectLock.ts
T
Miguel Ángel 00ea86570a fix(cli): a command waiting on the project lock says what it waits for (#7184)
* fix(cli): a command waiting on the project lock says what it waits for

* fix(cli): the project lock timeout says to run the command again
2026-11-04 21:01:53 +00:00

129 lines
4.1 KiB
TypeScript

import { mkdirSync, readFileSync, unlinkSync } from "node:fs";
import { createFileAtomically } from "@hyperframes/core/atomic-file";
import { dirname, join } from "node:path";
import { setTimeout as sleep } from "node:timers/promises";
import { readToolContext, type ToolContext } from "./toolContext.js";
export class ProjectLockTimeout extends Error {}
export interface Holder {
pid: number;
command: string;
startedAt: number;
}
const POLL_MS = 250;
export const projectLockPath = (projectDir: string) =>
join(projectDir, ".hyperframes", "project.lock");
export function readHolder<T extends Holder = Holder>(path: string): T | null {
try {
return JSON.parse(readFileSync(path, "utf8")) as T;
} catch {
return null;
}
}
export function alive(pid: number): boolean {
try {
process.kill(pid, 0);
return true;
} catch (error) {
return (error as NodeJS.ErrnoException).code === "EPERM";
}
}
const sameHolder = (a: Holder | null, b: Holder) =>
a?.pid === b.pid && a.startedAt === b.startedAt && a.command === b.command;
function breakStaleHolder(path: string, current: Holder, holder: Holder): boolean {
const breakPath = `${path}.break`;
if (!createNew(breakPath, holder)) return false;
try {
if (sameHolder(readHolder(path), current)) {
try {
unlinkSync(path);
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
}
}
return tryAcquire(path, holder);
} finally {
if (sameHolder(readHolder(breakPath), holder)) unlinkSync(breakPath);
}
}
function createNew(path: string, holder: Holder): boolean {
try {
createFileAtomically(path, JSON.stringify(holder));
return true;
} catch (error) {
if ((error as NodeJS.ErrnoException).code === "EEXIST") return false;
throw error;
}
}
function tryAcquire(path: string, holder: Holder): boolean {
if (createNew(path, holder)) return true;
const current = readHolder(path);
if (current && !alive(current.pid)) return breakStaleHolder(path, current, holder);
return false;
}
const FIRST_NOTICE_MS = 5_000;
const NOTICE_EVERY_MS = 30_000;
function sayWaiting(current: Holder | null, waitMs: number): void {
if (!current) return;
const running = Math.round((Date.now() - current.startedAt) / 1000);
console.error(
`[hyperframes] waiting for ${current.command} (pid ${current.pid}, running ${running}s) to finish with this project; waiting up to ${Math.round(waitMs / 1000)}s`,
);
}
export async function withProjectLock<T>(
projectDir: string,
command: string,
run: () => Promise<T>,
context: ToolContext = readToolContext(),
): Promise<T> {
if (!context.projectLock) return run();
const path = projectLockPath(projectDir);
mkdirSync(dirname(path), { recursive: true });
const holder: Holder = { pid: process.pid, command, startedAt: Date.now() };
const deadline = holder.startedAt + context.projectLock.waitMs;
let nextNoticeAt = holder.startedAt + FIRST_NOTICE_MS;
while (!tryAcquire(path, holder)) {
if (Date.now() >= nextNoticeAt) {
nextNoticeAt = Date.now() + NOTICE_EVERY_MS;
sayWaiting(readHolder(path), context.projectLock.waitMs);
}
const remaining = deadline - Date.now();
if (remaining <= 0) {
const current = readHolder(path);
const breakPath = `${path}.break`;
const breaker = readHolder(breakPath);
if ((!current || !alive(current.pid)) && breaker && !alive(breaker.pid)) {
throw new ProjectLockTimeout(
`hyperframes left ${breakPath} (pid ${breaker.pid}); delete it to continue`,
);
}
throw new ProjectLockTimeout(
`hyperframes ${current?.command ?? "another command"} (pid ${current?.pid ?? "unknown"}) ` +
`is still using this project after ${Math.round(context.projectLock.waitMs / 1000)}s. Run this command again when it finishes.`,
);
}
await sleep(Math.min(POLL_MS, remaining));
}
try {
return await run();
} finally {
release(path, holder);
}
}
export function release(path: string, holder: Holder): void {
if (sameHolder(readHolder(path), holder)) unlinkSync(path);
}