@volter/supercode-health 0.1.11 → 0.1.13

package/lib/drift.mjs

@@ -5,7 +5,10 @@
 // A process runs a file of a supercode install (the native, `…/@volter/supercode-cli-<os>-<cpu>/bin/supercode`, or
 // node running a file of an `@volter/supercode*` package); when that file was written after the process started (its
 // ctime: an extractor may set a file's mtime, never its ctime), the release on disk is not the one it runs.
-import { statSync } from 'node:fs';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import { run } from './run.mjs';
 
 /** A supercode install's file: the native, or a script of an @volter/supercode* package. */
@@ -15,8 +18,26 @@ const INSTALL_FILE = /^\/\S*\/node_modules\/@volter\/supercode(?:-[a-z0-9-]+)?\/
  *  one, never a path in its arguments (a Claude session's `--settings` names supercode's hooks). */
 function ran(command) {
   const words = command.split(/\s+/u);
-  const program = /(^|\/)node$/u.test(words[0] ?? '') ? words.slice(1).find((word) => !word.startsWith('-')) : words[0];
-  return program && INSTALL_FILE.test(program) ? program : null;
+  const node = /(^|\/)node$/u.test(words[0] ?? '');
+  let program = node ? words.slice(1).find((word) => !word.startsWith('-')) : words[0];
+  if (!program?.startsWith('/')) return null;
+  // by its real path: a link (the machine's stable program, a bin link) names an install's file under another name
+  try { program = realpathSync(program); } catch { /* gone: matched as named */ }
+  return INSTALL_FILE.test(program) ? { file: program, native: !node } : null;
+}
+
+/** The inode each native process runs (its `txt` mapping, lsof's first), by pid; empty where lsof cannot say. An
+ *  install that replaced the file gave its path a new inode, while the process still runs the old one. */
+async function runningInodes(pids) {
+  const inodes = new Map();
+  if (!pids.length) return inodes;
+  const answer = await run('lsof', ['-n', '-P', '-a', '-d', 'txt', '-F', 'pi', '-p', pids.join(',')], { timeoutMs: 10_000 }).catch(() => null);
+  let pid = null;
+  for (const line of String(answer?.stdout ?? '').split('\n')) {
+    if (line.startsWith('p')) pid = Number(line.slice(1));
+    else if (line.startsWith('i') && pid && !inodes.has(pid)) inodes.set(pid, Number(line.slice(1)));
+  }
+  return inodes;
 }
 
 /** `ps`'s start time (`lstart`, as `Tue Oct  6 12:09:42 2026`) in ms, or NaN. */
@@ -29,19 +50,56 @@ const startedMs = (lstart) => Date.parse(String(lstart).trim().replace(/\s+/g, '
  */
 export async function staleSupercode({ rows = null } = {}) {
   const lines = rows ?? String((await run('ps', ['-A', '-ww', '-o', 'pid=,lstart=,command='], { timeoutMs: 10_000 })).stdout ?? '').split('\n');
-  const stale = [];
+  const found = [];
   for (const line of lines) {
     const match = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/u.exec(line);
     if (!match) continue;
     const [, pid, lstart, command] = match;
-    const file = ran(command);
-    if (!file) continue;
+    const program = ran(command);
+    if (program) found.push({ pid: Number(pid), lstart, command, ...program });
+  }
+  // a native is read by the inode it runs, where lsof says it: the strongest reading (a ctime also moves on a chmod)
+  const inodes = rows ? new Map() : await runningInodes(found.filter((row) => row.native).map((row) => row.pid));
+  const stale = [];
+  for (const { pid, lstart, command, file } of found) {
     const started = startedMs(lstart);
-    let installed;
-    try { installed = statSync(file).ctimeMs; } catch { continue; } // a file gone is a removed install, said elsewhere
-    // ps says a start to the second: a file written within that second is the same start
-    if (Number.isNaN(started) || installed <= started + 1000) continue;
+    let stat;
+    try { stat = statSync(file); } catch { continue; } // a file gone is a removed install, said elsewhere
+    const installed = stat.ctimeMs;
+    if (inodes.has(pid)) {
+      if (inodes.get(pid) === stat.ino) continue;
+    } else if (Number.isNaN(started) || installed <= started + 1000) continue; // ps says a start to the second
     stale.push({ pid: Number(pid), command: command.slice(0, 200), file, startedAt: new Date(started).toISOString(), installedAt: new Date(installed).toISOString() });
   }
   return stale.sort((a, b) => b.installedAt.localeCompare(a.installedAt));
 }
+
+/**
+ * Board homes served by an orchestrator other than the machine's (t_8e109edc): a home records the orchestrator and
+ * the supercode that serve it (`<home>/orchestrator.json`, hand-off.mjs obeys it on every command). On npm's prefix that
+ * path follows each upgrade in place; a home made by another install (a scratch prefix, a removed `~/.local`, a kit's
+ * per-version install) stays served by it until its path is gone, and then refuses. Each home this machine's daemon
+ * holds a board for (`<home>/board-homes.json`): `[{ home, version, entry, why }]` where its record names another
+ * orchestrator than the one installed beside this package, or one that is not on this machine.
+ */
+export function pinnedHomes({ home = null } = {}) {
+  const supercodeHome = home ?? (process.env.SUPERCODE_HOME || (process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, 'supercode') : join(homedir(), '.config', 'supercode')));
+  let held = {};
+  try { held = JSON.parse(readFileSync(join(supercodeHome, 'board-homes.json'), 'utf8')) ?? {}; } catch { return []; }
+  let own = null;
+  // its package's own folder (its exports name no bin), from its main module up to its package.json
+  try {
+    let dir = dirname(fileURLToPath(import.meta.resolve('@volter/supercode-orchestrator'))); // an import-only package
+    while (dir !== dirname(dir) && JSON.parse((() => { try { return readFileSync(join(dir, 'package.json'), 'utf8'); } catch { return '{}'; } })()).name !== '@volter/supercode-orchestrator') dir = dirname(dir);
+    own = realpathSync(join(dir, 'bin', 'orchestrator.mjs'));
+  } catch { /* none beside this package: a checkout */ }
+  const pinned = [];
+  for (const root of new Set(Object.values(held).filter((value) => typeof value === 'string'))) {
+    let record = null;
+    try { record = JSON.parse(readFileSync(join(root, 'orchestrator.json'), 'utf8')); } catch { continue; } // no record: the machine's own serves it
+    let entry = null;
+    try { entry = realpathSync(record.entry); } catch { pinned.push({ home: root, version: record.version ?? null, entry: record.entry ?? null, why: 'its orchestrator is not on this machine' }); continue; }
+    if (own && entry !== own) pinned.push({ home: root, version: record.version ?? null, entry, why: `served by ${entry}, not the machine's ${own}` });
+  }
+  return pinned;
+}

package/lib/sample.mjs

@@ -7,7 +7,7 @@ import { daemonCall } from './mail.mjs';
 import { rendererOrigins, originOf, localPort } from './chrome.mjs';
 import { expiredFailures, failureSummary, keyFor, Ledger, runningRelease, sayOnChanges, slowFailures } from './failures.mjs';
 import { healthDir } from './paths.mjs';
-import { staleSupercode } from './drift.mjs';
+import { pinnedHomes, staleSupercode } from './drift.mjs';
 import { join } from 'node:path';
 
 const MB = 1024 * 1024;
@@ -392,6 +392,12 @@ export class Sampler {
       slow.observations.push({ enumerated: 'release', family: 'release', by: 'suffix', entities: new Set(stale.map((r) => String(r.pid))) });
       slow.readings.drift = stale;
       for (const r of stale) slow.observations.push({ key: `release.drift:${r.pid}`, family: 'release', def: alarm('release.drift'), value: 1, met: { warn: true, crit: false, clears: false }, summary: `supercode process ${r.pid} runs a release replaced at ${r.installedAt} (started ${r.startedAt}): ${r.command.slice(0, 120)}`, detail: r });
+      // board homes served by another install's orchestrator: their own family, cleared when a home's record moves
+      const pinned = pinnedHomes();
+      slow.families.add('pinned');
+      slow.observations.push({ enumerated: 'pinned', family: 'pinned', by: 'suffix', entities: new Set(pinned.map((p) => p.home)) });
+      slow.readings.pinned = pinned;
+      for (const p of pinned) slow.observations.push({ key: `release.pinned:${p.home}`, family: 'pinned', def: alarm('release.pinned'), value: 1, met: { warn: true, crit: false, clears: false }, summary: `board home ${p.home} is ${p.why} (orchestrator ${p.version ?? 'unknown'})`, detail: p });
     });
     if (on.has('services')) await attempt('services', async () => {
       const list = cfg.services ?? [];

package/lib/thresholds.mjs

@@ -34,6 +34,8 @@ export const DEFAULTS = {
     'service.down': { forSec: 60 },
     // a process on a replaced release keeps speaking to the new one as the old: said once it has run so 5 min
     'release.drift': { forSec: 300 },
+    // a board home its record holds to another install's orchestrator: said once it has stayed so 5 min
+    'release.pinned': { forSec: 300 },
     'supercode.connector': { forSec: 60 },
     'supercode.launch': { stuckMin: 5, failedWithinMin: 30 },
     // one failure that keeps happening (the same command or door with the same outcome, the same mail expiry) in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-health",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "description": "Optional machine pack: a cheap, deterministic probe of a machine's vitals that mails the machine's maintainer when a threshold is crossed. Each feature sits behind its own permission barrier.",
   "license": "MIT",