Function acquireLock

index.js:668–760

()

}

function acquireLock() {
  const lockFile = getLockFilePath();
  // NOTE(windows): mode 0o700 / 0o600 are silently ignored on Windows.
  // Lock directory and file permissions provide no OS-level isolation on
  // Windows; rely on user-profile directory ACLs (%USERPROFILE%\.evomap).
  try {
    try { fs.mkdirSync(path.dirname(lockFile), { recursive: true, mode: 0o700 }); } catch (_) {}
    try {
      fs.writeFileSync(lockFile, _lockPayload(), { flag: 'wx', mode: 0o600 });
      return true;
    } catch (exclErr) {
      if (exclErr.code !== 'EEXIST') throw exclErr;
    }
    const payload = _readLockPayload(lockFile);
    if (!payload || !Number.isFinite(payload.pid) || payload.pid <= 0) {
      console.log('[Singleton] Corrupt lock file. Taking over.');
    } else if (_lockIsStaleByLease(lockFile, payload)) {
      // Round-9: a lease-aware daemon has not refreshed this lock's mtime
      // within the stale TTL. Either it was SIGKILLed/crashed, or its PID
      // has since been reused by an unrelated process (kill(0) below would
      // then falsely report it alive and we would refuse to start forever).
      // The expired lease is authoritative: take over.
      console.log('[Singleton] Lock lease expired (PID ' + payload.pid + ', no mtime refresh for > ' +
        Math.round(STALE_LOCK_TTL_MS / 60_000) + 'min). Taking over.');
    } else {
      try {
        process.kill(payload.pid, 0);
        // Process exists. Distinguish "alive, our user" (refuse) from
        // "alive, different uid" (also refuse -- never barge into a root
        // daemon under a user-launched evolver, etc.).
        console.log(`[Singleton] Evolver loop already running (PID ${payload.pid}). Exiting.`);
        return false;
      } catch (e) {
        if (e && e.code === 'EPERM') {
          // PID exists but belongs to another user. Conservatively
          // refuse: barging in would race the existing daemon for
          // secret/heartbeat ownership.
          console.warn(`[Singleton] Lock owned by PID ${payload.pid} (different user). Refusing to take over. ` +
            `Remove ${lockFile} manually if the PID is actually dead.`);
          return false;
        }
        console.log(`[Singleton] Stale lock found (PID ${payload.pid}). Taking over.`);
      }
    }
    // Atomic takeover so two daemons that both observe the same stale PID
    // and pass the kill(0) check cannot both end up "owning" the lock.
    //
    // Bug it fixes: the previous "unconditional unlinkSync then linkSync"
    // pattern was NOT atomic across acquirers. Interleaving where P1 wins
    // the linkSync but P2's unlinkSync then deletes P1's freshly-linked
    // file (P2 never re-verifies it's deleting the same stale lock it
    // observed) lets P2's subsequent linkSync also succeed. Both processes
    // then return true and start a daemon, racing each other on the
    // shared singleton secret store.
    //
    // renameSync is atomic at the filesystem level: only one of N racing
    // acquirers can move the stale lockFile to a unique claim name, the
    // rest see ENOENT and abort. After the claim succeeds, _writeLockAtomic