@volter/supercode-health 0.1.18 → 0.1.19

package/lib/mail.mjs

@@ -59,6 +59,33 @@ export function daemonCall(method, params, { env = process.env, timeoutMs = 15_0
   });
 }
 
+/**
+ * Whether this machine's daemon answers its local socket, asked from outside it: a connection and the daemon's hello.
+ * `{ state: 'answered', ms }`, `{ state: 'silent', connected, ms }` (nothing came back within `timeoutMs`; a socket
+ * whose process is alive and serving nothing still takes the connection, since the kernel holds the queue), or
+ * `{ state: 'absent', error }` (nothing listens there). No request is made, so it reads the daemon's event loop alone.
+ */
+export function daemonHello({ env = process.env, timeoutMs = 6_000 } = {}) {
+  return new Promise((resolve) => {
+    const started = performance.now(), socket = connect(daemonSocket(env));
+    let connected = false, buffer = Buffer.alloc(0);
+    const done = (value) => { clearTimeout(timer); socket.destroy(); resolve({ ...value, ms: Math.round(performance.now() - started) }); };
+    const timer = setTimeout(() => done({ state: 'silent', connected }), timeoutMs);
+    socket.on('error', (error) => done(connected ? { state: 'silent', connected, error: error.message } : { state: 'absent', error: error.code ?? error.message }));
+    socket.on('close', () => done({ state: 'silent', connected, error: 'the socket closed before the daemon answered' }));
+    socket.on('connect', () => {
+      connected = true;
+      const bytes = Buffer.from(JSON.stringify({ p: 'supercode-machine/1', nv: 3 })), head = Buffer.alloc(4);
+      head.writeUInt32BE(bytes.length, 0);
+      socket.write(Buffer.concat([head, bytes]));
+    });
+    socket.on('data', (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length >= 4 && buffer.length >= 4 + buffer.readUInt32BE(0)) done({ state: 'answered' });
+    });
+  });
+}
+
 /** File one alarm mail for each address. Answers what was filed and the first failure, if any. */
 export async function fileAlarm({ machine, env = process.env, to, key, subject, body }) {
   const filed = [];

package/lib/promises.mjs

@@ -15,7 +15,7 @@ import { homedir, tmpdir, userInfo } from 'node:os';
 import { delimiter, isAbsolute, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { run } from './run.mjs';
-import { daemonCall } from './mail.mjs';
+import { daemonCall, daemonHello } from './mail.mjs';
 import { healthDir, machineName } from './paths.mjs';
 import { staleSupercode } from './drift.mjs';
 import { harnessMarks } from './markers.mjs';
@@ -41,6 +41,7 @@ export const PROMISE_DEFAULTS = Object.freeze({
   diskFreeGB: 5,           // extrapolated: admission's copy of an 800 MB mailbox and an install both need room
   fleetSeenHours: 24,      // a machine silent longer than this is taken to be off, not broken
   harnesses: ['codex', 'claude'],
+  daemonAnswerMs: 6000,    // extrapolated: above the longest step the daemon is known to wait on in one call (a 5 s child)
 });
 
 /** The server's machine list, asked once a pass and shared by the two promises that read it. The server alone can say
@@ -117,6 +118,27 @@ const PROBES = {
       : yes(`the daemon (pid ${record.pid}) serves mail; none expired undelivered in the last ${context.lines.mailExpiryMin} min`, detail);
   },
 
+  // The daemon is one event loop: one call the operating system does not return from stops its heartbeat, its link,
+  // its socket and its mail at once, with the process alive, so nothing that watches for an exit sees it. This probe
+  // is a process of its own and asks the socket from outside. A daemon that is not running at all is not this
+  // promise's to say (`server-sees-machine` reads false for it, and a restart passes through that state): unknown.
+  async socket(context) {
+    const record = json(join(teamsHome(context.env), 'machine.json'));
+    if (!record?.pid) return unknown('no machine daemon has a record on this machine');
+    const bound = context.lines.daemonAnswerMs;
+    const answer = await daemonHello({ env: context.env, timeoutMs: bound });
+    let alive = true; try { process.kill(record.pid, 0); } catch (error) { alive = error.code === 'EPERM'; }
+    const detail = { pid: record.pid, alive, state: answer.state, connected: answer.connected ?? null, ms: answer.ms, error: answer.error ?? null };
+    if (answer.state === 'answered') return yes(`the daemon (pid ${record.pid}) answered its socket in ${answer.ms} ms`, detail);
+    if (!alive) return unknown(`the daemon's recorded process (pid ${record.pid}) is not running`);
+    // said where it is read: the daemon carries this machine's mail, so this alarm waits in the health snapshot and
+    // log, and is filed when the daemon answers again
+    const route = 'while it does not answer it sends no heartbeat and files no mail, this alarm included: it stands in this machine\'s health snapshot and log until the daemon answers or its service is restarted';
+    return answer.state === 'silent'
+      ? no(`the daemon's process (pid ${record.pid}) is alive and ${answer.connected ? 'took a connection on its socket but did not answer it' : 'did not take a connection on its socket'} within ${bound / 1000} s; ${route}`, detail)
+      : no(`the daemon's process (pid ${record.pid}) is alive and nothing listens on its socket (${answer.error}); ${route}`, detail);
+  },
+
   // The login shell is started because only it can say its PATH (its profile builds it), and each install is asked its
   // own version because only it knows: the two things a launch does. Codex's background server names its version in
   // the folder it runs from, which is read from the process list.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-health",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "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",

package/promises.json

@@ -8,6 +8,8 @@
       "promise": "A restart of this machine's daemon would not be refused for state already standing here (the runtime, the pane wrappers, the Maildir against its retirement receipt)." },
     { "name": "mail-serves", "probe": "mail", "bound_ms": 1500, "activation": "report",
       "promise": "The daemon answers on its socket, serves mail, and no mail expired undelivered in the last 15 minutes." },
+    { "name": "daemon-answers", "probe": "socket", "bound_ms": 6500, "activation": "report",
+      "promise": "The daemon's running process answers its local socket within 6 seconds, asked by the health probe's own process: it serves, not only lives." },
     { "name": "harness-one-install", "probe": "harness", "bound_ms": 4000, "activation": "report",
       "promise": "Each harness CLI on this machine (codex, claude) is one version wherever a launch could find it (the login shell's PATH, then the daemon's), and Codex's background server runs that version." },
     { "name": "no-harness-marks", "probe": "marks", "bound_ms": 2000, "activation": "report",