scripts/lib/session-lock.js

#!/usr/bin/env node

'use strict';
/**

 * session-lock.js — cross-harness soft session lock (Nomad scripts/ port).

 *

 * Purpose: the same agent home can get opened by more than one harness/session

 * at once (a human borrowing the same agent from two tools, an automated check

 * plus a manual window, etc). This is a SOFT lock — it never blocks anyone, it

 * only turns "I don't know if someone else is in here" into a visible warning

 * that a human or the calling agent can act on. It is deliberately not a real

 * mutex: portable teams get borrowed across harnesses on purpose, and a hard

 * lock would get in the way of that legitimate workflow.

 *

 * State file: `<memory-dir>/.session_lock.json` where memory-dir is whichever

 * of the naming candidates (`记忆`, `memory`) exists under the agent home —

 * see config.js firstExisting() and the "naming agnosticism" note in README.md.

 * If neither exists yet, the lock file is written straight into the agent home

 * root as a last resort so the feature degrades instead of throwing.

 *

 * Exposed both as a requirable module (used by session-start.js/session-stop.js

 * directly — no subprocess needed since everything lives in the same package)

 * and as a standalone CLI for manual diagnosis:

 *   node session-lock.js acquire <agent-home-abs-path> <harness-name>

 *   node session-lock.js release <agent-home-abs-path>

 *   node session-lock.js check   <agent-home-abs-path>

 */
const fs = require('fs');
const path = require('path');
const cfg = require('./config');

const TTL_MS = 4 * 60 * 60 * 1000; // 4 hours

const MEMORY_DIR_CANDIDATES = ['记忆', 'memory'];
const LOCK_FILENAME = '.session_lock.json';

function lockFilePath(agentHome) {
  const memDir = cfg.firstExisting(agentHome, MEMORY_DIR_CANDIDATES) || agentHome;
  return path.join(memDir, LOCK_FILENAME);
}

function readLockFile(lp) {
  if (!fs.existsSync(lp)) return null;
  try {
    return JSON.parse(cfg.readTextFileStripBOM(lp));
  } catch (e) {
    return null; // a corrupted lock file is treated as "no lock" — never let it wedge the flow
  }
}

function isExpired(lockData, now) {
  if (!lockData || !lockData.acquiredAt) return true;
  const acquiredMs = Date.parse(lockData.acquiredAt);
  if (Number.isNaN(acquiredMs)) return true;
  const ttlMs = typeof lockData.ttlMs === 'number' ? lockData.ttlMs : TTL_MS;
  return now - acquiredMs > ttlMs;
}

function acquire(agentHome, harness) {
  if (!agentHome || !fs.existsSync(agentHome)) return { ok: false, error: 'agent home does not exist: ' + agentHome };
  if (!harness) return { ok: false, error: 'missing harness name' };
  const lp = lockFilePath(agentHome);
  try {
    fs.mkdirSync(path.dirname(lp), { recursive: true });
  } catch (e) {
    /* ignore — writeFileSync below will surface any real problem */
  }
  const now = Date.now();
  const existing = readLockFile(lp);
  let warned = false;
  let priorHolder = null;
  if (existing && !isExpired(existing, now)) {
    warned = true;
    priorHolder = existing;
  }
  const newLock = { harness: harness, pid: process.pid, acquiredAt: new Date(now).toISOString(), ttlMs: TTL_MS };
  try {
    fs.writeFileSync(lp, JSON.stringify(newLock, null, 2), 'utf8');
  } catch (e) {
    return { ok: false, error: 'failed to write lock file: ' + e.message };
  }
  return { ok: true, warned: warned, priorHolder: priorHolder, current: newLock, path: lp };
}

function release(agentHome) {
  if (!agentHome || !fs.existsSync(agentHome)) return { ok: false, error: 'agent home does not exist: ' + agentHome };
  const lp = lockFilePath(agentHome);
  let existed = fs.existsSync(lp);
  try {
    fs.unlinkSync(lp);
  } catch (e) {
    existed = false; // missing or failed delete both read as "already released" — release is idempotent
  }
  return { ok: true, existed: existed, path: lp };
}

function check(agentHome) {
  if (!agentHome || !fs.existsSync(agentHome)) return { ok: false, error: 'agent home does not exist: ' + agentHome };
  const lp = lockFilePath(agentHome);
  const existing = readLockFile(lp);
  if (!existing) return { ok: true, hasLock: false, path: lp };
  return { ok: true, hasLock: true, expired: isExpired(existing, Date.now()), lock: existing, path: lp };
}

function main() {
  const argv = process.argv.slice(2);
  const sub = argv[0];
  const agentHome = argv[1] ? path.resolve(argv[1]) : null;
  const harness = argv[2];
  let result;
  if (sub === 'acquire') result = acquire(agentHome, harness);
  else if (sub === 'release') result = release(agentHome);
  else if (sub === 'check') result = check(agentHome);
  else result = { ok: false, error: 'unknown subcommand: ' + sub + ' (supported: acquire|release|check)' };
  process.stdout.write(JSON.stringify(result) + '\n');
  if (!result.ok) process.exitCode = 1;
}

if (require.main === module) {
  main();
}

module.exports = { lockFilePath, isExpired, acquire, release, check, TTL_MS, MEMORY_DIR_CANDIDATES };