Дмитрий
108 lines
4.4 KiB
JavaScript
108 lines
4.4 KiB
JavaScript
// tools/parallel-session-lock.mjs
|
|
/**
|
|
* Pure parallel-session lock — router-gate v4 Stream H Task 7.
|
|
*
|
|
* Prevents two Claude sessions on the same workspace from concurrently
|
|
* mutating files. Lock file lives at
|
|
* ~/.claude/runtime/session-lock-<workspaceHash>.json
|
|
* with TTL-based stale recovery (default 5 minutes).
|
|
*
|
|
* I/O is injected (readLock/writeLock/deleteLock) so this module stays pure
|
|
* and unit-testable. The wrapper hook (enforce-parallel-session-lock.mjs)
|
|
* binds real fs implementations.
|
|
*
|
|
* Lock format:
|
|
* { schema_version: 1, session_id, pid, acquired_at: <ms>, ttl_ms }
|
|
*/
|
|
import { createHash } from 'node:crypto';
|
|
|
|
export const LOCK_SCHEMA_VERSION = 1;
|
|
export const LOCK_DEFAULT_TTL_MS = 5 * 60 * 1000;
|
|
|
|
/** Derive a deterministic 12-char hex workspace hash from a path. */
|
|
export function computeWorkspaceHash(workspacePath) {
|
|
return createHash('md5').update(String(workspacePath || ''), 'utf-8').digest('hex').slice(0, 12);
|
|
}
|
|
|
|
function isStale(record, now) {
|
|
if (!record || typeof record !== 'object') return true;
|
|
const ttl = typeof record.ttl_ms === 'number' ? record.ttl_ms : LOCK_DEFAULT_TTL_MS;
|
|
return now - (record.acquired_at || 0) > ttl;
|
|
}
|
|
|
|
/**
|
|
* 7.5 (дыра 5): жив ли процесс-держатель. process.kill(pid, 0) не убивает — лишь проверяет
|
|
* существование: ESRCH → мёртв; EPERM → существует (нет прав) → жив; иначе → жив. Невалидный
|
|
* pid → мёртв. Реальная реализация для обёртки; в acquire инъектируется (чистота/тестируемость).
|
|
*/
|
|
export function isProcessAlive(pid) {
|
|
if (typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0) return false;
|
|
try { process.kill(pid, 0); return true; }
|
|
catch (e) { return e && e.code === 'EPERM'; }
|
|
}
|
|
|
|
/**
|
|
* Try to acquire the lock for sessionId. Takes over stale or same-session locks.
|
|
*
|
|
* @param {object} args
|
|
* @param {string} args.sessionId
|
|
* @param {number} args.pid
|
|
* @param {string} args.workspaceHash
|
|
* @param {number} args.now - unix ms
|
|
* @param {function} args.readLock - () => record | null
|
|
* @param {function} args.writeLock - (record) => void
|
|
* @param {number} [args.ttlMs] - override default TTL
|
|
* @returns {{acquired: boolean, holder?: {session_id, pid, acquired_at}}}
|
|
*/
|
|
export function acquire({ sessionId, pid, workspaceHash, now, readLock, writeLock, ttlMs = LOCK_DEFAULT_TTL_MS, isPidAlive }) {
|
|
const existing = readLock();
|
|
// 7.5 (дыра 5): держатель свежего лока, чей процесс МЁРТВ, не должен блокировать на весь TTL.
|
|
// Перехватываем, если isPidAlive предоставлен и holder.pid не жив. Без isPidAlive — старое
|
|
// поведение (backward-compat): перехват только по stale/same-session.
|
|
const holderDead = !!existing && typeof isPidAlive === 'function' && !isPidAlive(existing.pid);
|
|
// Stale OR same-session OR dead-holder → take over.
|
|
if (!existing || isStale(existing, now) || existing.session_id === sessionId || holderDead) {
|
|
const record = {
|
|
schema_version: LOCK_SCHEMA_VERSION,
|
|
session_id: sessionId,
|
|
pid,
|
|
acquired_at: now,
|
|
ttl_ms: ttlMs,
|
|
};
|
|
writeLock(record);
|
|
return { acquired: true, holder: { session_id: sessionId, pid, acquired_at: now } };
|
|
}
|
|
// Fresh lock from another session — blocked.
|
|
return {
|
|
acquired: false,
|
|
holder: { session_id: existing.session_id, pid: existing.pid, acquired_at: existing.acquired_at },
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Same-session refresh — bumps acquired_at if we still own the lock.
|
|
* Other-session refresh is a no-op (does not steal).
|
|
*
|
|
* @returns {{refreshed: boolean}}
|
|
*/
|
|
export function refresh({ sessionId, workspaceHash, now, readLock, writeLock, ttlMs = LOCK_DEFAULT_TTL_MS }) {
|
|
const existing = readLock();
|
|
if (!existing || existing.session_id !== sessionId) return { refreshed: false };
|
|
writeLock({
|
|
schema_version: LOCK_SCHEMA_VERSION,
|
|
session_id: sessionId,
|
|
pid: existing.pid,
|
|
acquired_at: now,
|
|
ttl_ms: ttlMs,
|
|
});
|
|
return { refreshed: true };
|
|
}
|
|
|
|
/**
|
|
* Release the lock if we own it; no-op otherwise.
|
|
*/
|
|
export function release({ sessionId, workspaceHash, readLock, deleteLock }) {
|
|
const existing = readLock();
|
|
if (existing && existing.session_id === sessionId) deleteLock();
|
|
}
|