@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/clients/instance-reaper.js

@@ -22,10 +22,23 @@ import {
   readInstanceRegistry
 } from "./instance-registry.js";
 import { logLatency } from "./latency-logger.js";
-import { queryProcessTable, windowsExe } from "./process-snapshot.js";
+import {
+  isInPidNamespace,
+  ownPidNamespace,
+  queryProcessIdentities,
+  queryProcessTable,
+  readOwnerTags,
+  windowsExe
+} from "./process-snapshot.js";
 const isWindows = process.platform === "win32";
-function isInstanceKillEligible(instance, isPidAlive) {
-  return !isPidAlive(instance.pid);
+function isInstanceKillEligible(instance, isPidAlive, startOf) {
+  if (!isPidAlive(instance.pid))
+    return true;
+  return isAnotherProcess(instance.processStart, startOf(instance.pid));
+}
+function isAnotherProcess(recorded, current) {
+  const bootOf = (start) => start.includes("@") ? start.slice(start.indexOf("@") + 1) : "";
+  return recorded !== undefined && current !== undefined && current !== recorded && bootOf(current) === bootOf(recorded);
 }
 function isInstanceEntryStale(instance, now) {
   const heartbeatMs = Date.parse(instance.heartbeatAt);
@@ -49,15 +62,17 @@ function classifyDeadInstanceChildren(instance, isPidAlive, matchProcess, liveMa
   for (const child of instance.lspChildren) {
     const childAlive = isPidAlive(child.pid);
     if (childAlive) {
-      const identityOk = matchProcess ? matchProcess(child.pid, {
+      const expected = {
         command: child.command,
-        marker: child.marker
-      }) : true;
+        marker: child.marker,
+        processStart: child.processStart
+      };
+      const identityOk = matchProcess ? matchProcess(child.pid, expected) : true;
       if (identityOk) {
         out.childrenToKill.push({
           pid: child.pid,
           serverId: child.serverId,
-          command: child.command
+          ...expected
         });
         continue;
       }
@@ -70,14 +85,16 @@ function classifyDeadInstanceChildren(instance, isPidAlive, matchProcess, liveMa
     }
   }
 }
-export function decideOrphanReaping(registry, isPidAlive, matchProcess, now = Date.now()) {
+export function decideOrphanReaping(registry, isPidAlive, matchProcess, now = Date.now(), startOf = () => {
+  return;
+}, judgeable = () => true) {
   const deadInstances = [];
   const staleInstances = [];
   const childrenToKill = [];
   const markerSearches = [];
   const liveMarkers = collectLiveMarkers(registry, isPidAlive);
   for (const instance of registry) {
-    if (isInstanceKillEligible(instance, isPidAlive)) {
+    if (judgeable(instance) && isInstanceKillEligible(instance, isPidAlive, startOf)) {
       deadInstances.push(instance);
       classifyDeadInstanceChildren(instance, isPidAlive, matchProcess, liveMarkers, {
         childrenToKill,
@@ -102,6 +119,15 @@ export function realIsPidAlive(pid) {
     return true;
   }
 }
+const STAGE_PID_PATTERN = /\.stage-(\d+)-/;
+export function isStaleStageFile(entry, artifactPrefix) {
+  if (!entry.startsWith(artifactPrefix))
+    return false;
+  const match = STAGE_PID_PATTERN.exec(entry);
+  if (!match)
+    return false;
+  return !realIsPidAlive(Number(match[1]));
+}
 export const ATOMIC_STAGE_SWEEP_MAX_ENTRIES = 512;
 export async function sweepAtomicWriteStages(directories, options = {}) {
   const requestedMax = options.maxEntries ?? ATOMIC_STAGE_SWEEP_MAX_ENTRIES;
@@ -132,15 +158,8 @@ async function findPidsByMarkerWindows(marker) {
   }
   return result.rows.map((row) => row.pid);
 }
-async function queryCommandLines(pids) {
-  const valid = [...new Set(pids.filter((p) => Number.isFinite(p) && p > 0))];
-  const map = new Map;
-  if (valid.length === 0)
-    return map;
-  const result = await queryProcessTable({
-    fields: ["pid", "command"],
-    filter: { column: "ProcessId", op: "eq", values: valid }
-  }, {
+async function queryIdentities(pids) {
+  const result = await queryProcessIdentities(pids, {
     timeoutMs: BACKSTOP_SCAN_TIMEOUT_MS,
     onTimeout: (child) => terminateScannerChild(child, {
       kind: "orphan-backstop-scanner-escalated",
@@ -148,22 +167,24 @@ async function queryCommandLines(pids) {
     })
   });
   const psReportedNoSuchPid = !isWindows && result.status === "exit-error";
-  if (result.status !== "ok" && !psReportedNoSuchPid) {
+  const failed = result.status !== "ok" && !psReportedNoSuchPid;
+  if (failed) {
     recordDegradationOnce({
       kind: "orphan-backstop-scan-failed",
       subject: "identity-query",
       reason: `command-line identity query ${result.status}; reap suppressed this sweep`
     });
   }
-  for (const row of result.rows)
-    map.set(row.pid, row.command);
-  return map;
+  return { identities: result.identities, failed };
 }
-export function buildIdentityMatcher(cmdlines) {
+export function buildIdentityMatcher(identities) {
   return (pid, expected) => {
-    const cmdline = cmdlines.get(pid);
-    if (cmdline === undefined)
+    const identity = identities.get(pid);
+    if (identity === undefined)
       return false;
+    if (expected.processStart === undefined || identity.start !== expected.processStart)
+      return false;
+    const cmdline = identity.command;
     if (expected.marker && cmdline.includes(expected.marker))
       return true;
     const basename = path.basename(expected.command ?? "").toLowerCase();
@@ -183,6 +204,8 @@ function sleepUnref(ms) {
 async function killPidTree(pid, options = {}) {
   if (!Number.isFinite(pid) || pid <= 0)
     return "invalid";
+  if (options.confirmIdentity && !await options.confirmIdentity())
+    return "changed";
   if (isWindows) {
     try {
       const taskkill = windowsExe("taskkill.exe");
@@ -244,27 +267,54 @@ export function decideBackstopOrphanReaping(processes, registry, isPidAlive, opt
   return partitionBackstopCandidates(processes, registry, isPidAlive, options).eligible;
 }
 export const BACKSTOP_SPAWN_GRACE_MS = 60000;
+function isOwnerDead(proc, isPidAlive, platform, startOf) {
+  if (platform !== "win32") {
+    const tag = proc.ownerTag;
+    if (tag === undefined)
+      return false;
+    if (!isPidAlive(tag.pid))
+      return true;
+    return isAnotherProcess(tag.start, startOf(tag.pid));
+  }
+  const parent = proc.parentPid;
+  if (!Number.isFinite(parent) || parent <= 0 || parent === proc.pid)
+    return false;
+  if (!isPidAlive(parent))
+    return true;
+  const parentStart = Date.parse(startOf(parent) ?? "");
+  return parentStart > Date.parse(proc.start ?? "") + WINDOWS_DST_MARGIN_MS;
+}
+const WINDOWS_DST_MARGIN_MS = 3600000;
 export function partitionBackstopCandidates(processes, registry, isPidAlive, options = {}) {
   const graceMs = Math.max(0, options.graceMs ?? BACKSTOP_SPAWN_GRACE_MS);
-  const trackedPids = new Set;
+  const platform = options.platform ?? process.platform;
+  const startOf = options.startOf ?? (() => {
+    return;
+  });
+  const trackedStarts = new Map;
   for (const instance of registry) {
-    for (const child of instance.lspChildren)
-      trackedPids.add(child.pid);
+    for (const child of instance.lspChildren) {
+      const starts = trackedStarts.get(child.pid) ?? [];
+      starts.push(child.processStart);
+      trackedStarts.set(child.pid, starts);
+    }
   }
+  const isTracked = (proc) => trackedStarts.get(proc.pid)?.some((start) => start === undefined || start === proc.start) === true;
   const partition = {
     eligible: [],
     tooFresh: [],
-    unknownAge: []
+    unknownAge: [],
+    unknownStart: []
   };
   for (const proc of processes) {
-    if (trackedPids.has(proc.pid))
+    if (isTracked(proc))
       continue;
-    if (!Number.isFinite(proc.parentPid) || proc.parentPid <= 0)
+    if (!isOwnerDead(proc, isPidAlive, platform, startOf))
       continue;
-    if (proc.parentPid === proc.pid)
-      continue;
-    if (isPidAlive(proc.parentPid))
+    if (proc.start === undefined) {
+      partition.unknownStart.push(proc);
       continue;
+    }
     if (graceMs > 0) {
       const ageMs = proc.ageMs;
       if (typeof ageMs !== "number" || !Number.isFinite(ageMs)) {
@@ -365,7 +415,29 @@ export async function sweepUntrackedOrphans(options = {}) {
         scanned: scan.processes.length
       }, options.onComplete);
     }
-    const partition = partitionBackstopCandidates(scan.processes, registry, realIsPidAlive, { graceMs: options.graceMs });
+    const pids = scan.processes.map((proc) => proc.pid);
+    const tagScan = await readTags(pids);
+    if (tagScan.status !== "ok") {
+      recordDegradationOnce({
+        kind: "orphan-backstop-scan-failed",
+        subject: "owner-tag-query",
+        reason: `owner tag query ${tagScan.status}; POSIX reap suppressed this sweep`
+      });
+    }
+    const tags = tagScan.tags;
+    const { identities } = await queryIdentities([
+      ...pids,
+      ...[...tags.values()].map((tag) => tag.pid),
+      ...scan.processes.map((proc) => proc.parentPid)
+    ]);
+    const partition = partitionBackstopCandidates(scan.processes.map((proc) => ({
+      ...proc,
+      start: identities.get(proc.pid)?.start,
+      ownerTag: tags.get(proc.pid)
+    })), registry, realIsPidAlive, {
+      graceMs: options.graceMs,
+      startOf: (pid) => identities.get(pid)?.start
+    });
     for (const proc of partition.unknownAge) {
       incrementDegradationCount({
         kind: "orphan-backstop-age-unknown",
@@ -375,12 +447,22 @@ export async function sweepUntrackedOrphans(options = {}) {
     }
     const killed = [];
     const unverified = [];
+    let identityChanged = 0;
     for (const proc of partition.eligible) {
       const identity = describeManagedProcess(proc);
       const outcome = await killPidTree(proc.pid, {
         verifyAttempts: options.verifyAttempts,
-        verifyIntervalMs: options.verifyIntervalMs
+        verifyIntervalMs: options.verifyIntervalMs,
+        confirmIdentity: async () => {
+          const now = (await queryIdentities([proc.pid])).identities.get(proc.pid);
+          const tagNow = (await readTags([proc.pid])).tags.get(proc.pid);
+          return now !== undefined && now.start === proc.start && matchesManagedBinary(now.command) && tagNow?.pid === proc.ownerTag?.pid && tagNow?.start === proc.ownerTag?.start;
+        }
       });
+      if (outcome === "changed") {
+        identityChanged++;
+        continue;
+      }
       if (outcome === "gone") {
         killed.push(identity);
         continue;
@@ -399,8 +481,12 @@ export async function sweepUntrackedOrphans(options = {}) {
       eligible: partition.eligible.length,
       tooFresh: partition.tooFresh.length,
       unknownAge: partition.unknownAge.length,
+      unknownStart: partition.unknownStart.length,
+      tagged: tags.size,
+      untagged: scan.processes.length - tags.size,
       killed: killed.length,
       killUnverified: unverified.length,
+      identityChanged,
       killedProcesses: killed.slice(0, BACKSTOP_IDENTITY_LOG_LIMIT),
       unverifiedProcesses: unverified.slice(0, BACKSTOP_IDENTITY_LOG_LIMIT),
       graceRetryInMs: retryAt
@@ -473,6 +559,15 @@ async function isWithinCooldown(now, cooldownMs, options) {
   const sinceLastMs = now - lastSweepAt;
   return sinceLastMs < cooldownMs ? sinceLastMs : undefined;
 }
+function readTags(pids) {
+  return readOwnerTags(pids, {
+    timeoutMs: BACKSTOP_SCAN_TIMEOUT_MS,
+    onTimeout: (child) => terminateScannerChild(child, {
+      kind: "orphan-backstop-scanner-escalated",
+      timeoutMs: BACKSTOP_SCAN_TIMEOUT_MS
+    })
+  });
+}
 function describeManagedProcess(proc) {
   const lower = proc.command.toLowerCase();
   const matched = MANAGED_BINARY_NAMES.find((name) => lower.includes(name.toLowerCase()));
@@ -522,15 +617,27 @@ export async function sweepOrphans() {
     const registry = await readInstanceRegistry();
     if (registry.length === 0)
       return;
-    const candidatePids = registry.flatMap((instance) => instance.lspChildren.map((child) => child.pid));
-    const cmdlines = await queryCommandLines(candidatePids);
-    const matchProcess = buildIdentityMatcher(cmdlines);
-    const decision = decideOrphanReaping(registry, realIsPidAlive, matchProcess);
+    const ownNamespace = ownPidNamespace();
+    const judgeable = (entry) => isInPidNamespace(entry, ownNamespace);
+    const candidatePids = registry.flatMap((instance) => [
+      instance.pid,
+      ...instance.lspChildren.map((child) => child.pid)
+    ]);
+    const { identities, failed } = await queryIdentities(candidatePids);
+    const matchProcess = buildIdentityMatcher(identities);
+    const decision = decideOrphanReaping(registry, realIsPidAlive, matchProcess, Date.now(), (pid) => identities.get(pid)?.start, judgeable);
     let killedCount = 0;
     let unverifiedCount = 0;
+    let identityChangedCount = 0;
     const killedServerIds = [];
-    const killAndAccount = async (pid, serverId) => {
-      const outcome = await killPidTree(pid);
+    const killAndAccount = async (pid, serverId, stillSame) => {
+      const outcome = await killPidTree(pid, {
+        confirmIdentity: async () => stillSame((await queryIdentities([pid])).identities)
+      });
+      if (outcome === "changed") {
+        identityChangedCount++;
+        return;
+      }
       if (outcome === "gone") {
         killedCount++;
         killedServerIds.push(serverId);
@@ -544,23 +651,27 @@ export async function sweepOrphans() {
       });
     };
     for (const child of decision.childrenToKill) {
-      await killAndAccount(child.pid, child.serverId);
+      await killAndAccount(child.pid, child.serverId, (now) => buildIdentityMatcher(now)(child.pid, child));
     }
     for (const search of decision.markerSearches) {
       try {
         const pids = await findPidsByMarkerWindows(search.marker);
         for (const pid of pids) {
-          await killAndAccount(pid, search.serverId);
+          await killAndAccount(pid, search.serverId, (now) => now.get(pid)?.command.includes(search.marker) === true);
         }
       } catch {}
     }
-    if (decision.deadInstances.length > 0 || decision.staleInstances.length > 0) {
+    const pruneTargets = [
+      ...failed ? [] : decision.deadInstances,
+      ...decision.staleInstances
+    ].map((instance) => ({
+      pid: instance.pid,
+      processStart: instance.processStart,
+      pidNamespace: instance.pidNamespace
+    }));
+    if (pruneTargets.length > 0) {
       try {
-        const prunePids = new Set([
-          ...decision.deadInstances.map((i) => i.pid),
-          ...decision.staleInstances.map((i) => i.pid)
-        ]);
-        await pruneDeadInstances(prunePids);
+        await pruneDeadInstances(pruneTargets);
       } catch {}
     }
     try {
@@ -574,6 +685,7 @@ export async function sweepOrphans() {
           staleInstances: decision.staleInstances.length,
           killed: killedCount,
           killUnverified: unverifiedCount,
+          identityChanged: identityChangedCount,
           serverIds: killedServerIds,
           markerSearches: decision.markerSearches.length
         }
@@ -581,8 +693,8 @@ export async function sweepOrphans() {
     } catch {}
   } catch {}
 }
-export async function pruneDeadInstances(deadPids) {
+export async function pruneDeadInstances(dead) {
   try {
-    await pruneDeadRegistryInstances(deadPids);
+    await pruneDeadRegistryInstances(dead);
   } catch {}
 }

package/extensions/dm-lens/clients/instance-registry-lock.js

@@ -2,42 +2,113 @@ import * as fs from "node:fs";
 import { randomInt } from "node:crypto";
 import * as path from "node:path";
 import { incrementDegradationCount } from "./degradation-ledger.js";
+import {
+  isLockContention,
+  pidFileIsStale,
+  pidFileOwner,
+  releaseGeneration,
+  tryAcquireGeneration
+} from "./generation-lock.js";
+import { getProcessSingleton } from "./process-singletons.js";
+const OWN_HOLDS_FAMILY = "instance-registry.lock-own-holds";
+const OWN_HOLDS_VERSION = 1;
+function ownAsyncHolds() {
+  return getProcessSingleton(OWN_HOLDS_FAMILY, OWN_HOLDS_VERSION, () => ({
+    count: 0
+  }));
+}
 const LOCK_STALE_MS = 5000;
 const LOCK_WAIT_MS = 500;
 const LOCK_MIN_BACKOFF_MS = 5;
 const LOCK_MAX_BACKOFF_MS = 25;
-function lockPath(target) {
+function generationDir(target) {
+  return `${target}.locks`;
+}
+function legacyLockPath(target) {
   return `${target}.lock`;
 }
-function ownerPid(lock) {
+function createLegacyLock(lock) {
   try {
-    const pid = Number(fs.readFileSync(lock, "utf8").trim().split(/\s+/)[0]);
-    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
-  } catch {
-    return;
+    fs.writeFileSync(lock, `${process.pid} ${Date.now()}
+`, { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (isLockContention(error))
+      return false;
+    throw error;
   }
 }
-function isPidAlive(pid) {
-  if (pid === undefined)
+function takeLegacyLock(lock) {
+  if (createLegacyLock(lock))
+    return true;
+  if (!pidFileIsStale(lock, LOCK_STALE_MS))
     return false;
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code !== "ESRCH";
-  }
+    fs.unlinkSync(lock);
+  } catch {}
+  return createLegacyLock(lock);
 }
-function staleLock(lock) {
+function releaseLegacyLock(lock) {
+  if (pidFileOwner(lock) !== process.pid)
+    return;
   try {
-    const stat = fs.statSync(lock);
-    if (Date.now() - stat.mtimeMs > LOCK_STALE_MS)
-      return true;
-    const pid = ownerPid(lock);
-    return pid !== undefined && !isPidAlive(pid);
-  } catch {
-    return false;
+    fs.unlinkSync(lock);
+  } catch {}
+}
+function tryAcquire(target) {
+  let hold;
+  try {
+    hold = tryAcquireGeneration(generationDir(target), LOCK_STALE_MS);
+    if (!hold)
+      return "busy";
+    if (hold.tookOverStale)
+      recordStaleTakeover(target, hold);
+    if (takeLegacyLock(legacyLockPath(target)))
+      return hold;
+    recordLegacyHeld(target);
+    releaseGeneration(hold);
+    return "busy";
+  } catch (cause) {
+    recordLockFailure(target, cause);
+    if (hold)
+      releaseGeneration(hold);
+    return "failed";
   }
 }
+function release(target, hold) {
+  releaseLegacyLock(legacyLockPath(target));
+  releaseGeneration(hold);
+}
+function recordLockFailure(target, cause) {
+  const code = cause?.code ?? "unknown";
+  incrementDegradationCount({
+    kind: "instance-registry-lock-failed",
+    subject: path.resolve(target),
+    reason: `lock acquisition failed for ${path.basename(target)} (${code}); the registry write was skipped`
+  });
+}
+function recordStaleTakeover(target, hold) {
+  incrementDegradationCount({
+    kind: "instance-registry-lock-stale-takeover",
+    subject: path.resolve(target),
+    reason: `took over lock generation ${hold.generation - 1} from a dead or aged-out holder`
+  });
+}
+function recordLegacyHeld(target) {
+  const lock = legacyLockPath(target);
+  incrementDegradationCount({
+    kind: "instance-registry-lock-legacy-held",
+    subject: path.resolve(lock),
+    reason: `backed off: ${path.basename(lock)} is held by pid ${pidFileOwner(lock) ?? "unknown"}, a writer from before #3476`
+  });
+}
+function recordOwnHold(target) {
+  incrementDegradationCount({
+    kind: "instance-registry-lock-own-hold",
+    subject: path.resolve(target),
+    reason: "did not wait: an async registry op of this process holds the lock"
+  });
+}
 function recordLockTimeout(target) {
   incrementDegradationCount({
     kind: "instance-registry-lock-timeout",
@@ -51,79 +122,49 @@ function backoffMs() {
 function backoff() {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, backoffMs());
 }
-function ownsLock(lock) {
-  return ownerPid(lock) === process.pid;
-}
-async function releaseLock(lock) {
-  if (ownsLock(lock))
-    await fs.promises.unlink(lock).catch(() => {});
-}
-function releaseLockSync(lock) {
-  if (!ownsLock(lock))
-    return;
-  try {
-    fs.unlinkSync(lock);
-  } catch {}
-}
-function takeOverStale(lock) {
-  if (!staleLock(lock))
-    return;
-  const displaced = `${lock}.stale-${process.pid}-${Date.now()}`;
-  try {
-    fs.renameSync(lock, displaced);
-    fs.unlinkSync(displaced);
-  } catch {}
-}
-function isLockContention(error) {
-  const code = error?.code;
-  return code === "EEXIST" || code === "EPERM" || code === "EBUSY";
-}
-export async function withInstanceRegistryLock(target, op) {
-  const lock = lockPath(target);
-  const deadline = Date.now() + LOCK_WAIT_MS;
-  await fs.promises.mkdir(path.dirname(target), { recursive: true });
+export const LOCK_WAIT_THROUGH_LEASE_MS = LOCK_STALE_MS + LOCK_WAIT_MS;
+export async function withInstanceRegistryLock(target, op, waitMs = LOCK_WAIT_MS) {
+  const deadline = Date.now() + waitMs;
   while (Date.now() <= deadline) {
-    try {
-      await fs.promises.writeFile(lock, `${process.pid} ${Date.now()}
-`, {
-        flag: "wx"
-      });
-    } catch (error) {
-      if (!isLockContention(error))
-        throw error;
-      takeOverStale(lock);
+    const hold = tryAcquire(target);
+    if (hold === "failed")
+      return;
+    if (hold === "busy") {
       if (Date.now() <= deadline)
         await new Promise((resolve) => setTimeout(resolve, backoffMs()));
       continue;
     }
+    const holds = ownAsyncHolds();
+    holds.count += 1;
     try {
       return await op();
     } finally {
-      await releaseLock(lock);
+      holds.count -= 1;
+      release(target, hold);
     }
   }
   recordLockTimeout(target);
   return;
 }
 export function withInstanceRegistryLockSync(target, op) {
-  const lock = lockPath(target);
+  if (ownAsyncHolds().count > 0) {
+    recordOwnHold(target);
+    return;
+  }
   const deadline = Date.now() + LOCK_WAIT_MS;
-  fs.mkdirSync(path.dirname(target), { recursive: true });
   while (Date.now() <= deadline) {
-    try {
-      fs.writeFileSync(lock, `${process.pid} ${Date.now()}
-`, { flag: "wx" });
-      try {
-        return op();
-      } finally {
-        releaseLockSync(lock);
-      }
-    } catch (error) {
-      if (!isLockContention(error))
-        throw error;
-      takeOverStale(lock);
+    const hold = tryAcquire(target);
+    if (hold === "failed")
+      return;
+    if (hold === "busy") {
       if (Date.now() <= deadline)
         backoff();
+      continue;
+    }
+    try {
+      return op();
+    } finally {
+      release(target, hold);
     }
   }
   recordLockTimeout(target);

package/extensions/dm-lens/clients/instance-registry-tail.js

@@ -0,0 +1,17 @@
+import { getProcessSingleton } from "./process-singletons.js";
+const REGISTRY_TAIL_FAMILY = "instance-registry.mutation-tail";
+const REGISTRY_TAIL_VERSION = 1;
+function registryTailState() {
+  return getProcessSingleton(REGISTRY_TAIL_FAMILY, REGISTRY_TAIL_VERSION, () => ({
+    tail: Promise.resolve()
+  }));
+}
+export function queueRegistryMutation(op) {
+  const state = registryTailState();
+  const run = state.tail.then(op);
+  state.tail = run.catch(() => {});
+  return run;
+}
+export function _settleRegistryMutationsForTests() {
+  return queueRegistryMutation(async () => {});
+}