@volter/supercode-health 0.1.6 → 0.1.7

package/lib/mail.mjs

@@ -1,20 +1,74 @@
-// Alarm mail, filed in each subscriber's mailbox through supercode's filing door (`supercode message file`), from
-// `sc:<machine>:operator:machine-health`, and delivered by the mailbox (docs/adr/0008-agent-mailbox.md, decision 17;
-// D138 step 6). Filing is a local write: no door, no network, and nothing for the probe to retry. The mailbox resolves
-// an agent address (`sc:<machine>:agent:<name>`) to the agent's main session when it delivers, retries within its
-// bounds, and records what it could not deliver (`supercode message waiting`, `supercode message expired`).
-import { spawnSync } from 'node:child_process';
+// Alarm mail, filed in each subscriber's mailbox by this machine's daemon (`harness.v1.mail.file`, its one filing,
+// sdk/teams/mail/send.mjs), from `sc:<machine>:operator:machine-health`, and delivered by the mailbox
+// (docs/adr/0008-agent-mailbox.md, decision 17; D138 step 6). Filing is a local write: one call on the daemon's local
+// socket, no network, and nothing for the probe to retry. The mailbox resolves an agent address
+// (`sc:<machine>:agent:<name>`) to the agent's main session when it delivers, retries within its bounds, and records what
+// it could not deliver (`supercode message waiting`, `supercode message expired`). This package has no dependencies, so
+// the call is made here with the daemon's own framing (sdk/volter-teams/channel.mjs).
+import { createHash } from 'node:crypto';
+import { connect } from 'node:net';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** Where this OS user's daemon serves its local door (sdk/volter-teams/home.mjs `machineSocketPath`). */
+export function daemonSocket(env = process.env) {
+  const home = env.SUPERCODE_HOME || (env.XDG_CONFIG_HOME ? join(env.XDG_CONFIG_HOME, 'supercode') : join(homedir(), '.config', 'supercode'));
+  const inside = join(env.SUPERCODE_TEAMS_HOME ?? join(home, 'teams'), 'machine.sock');
+  const hash = createHash('sha256').update(inside).digest('hex').slice(0, 24);
+  if (process.platform === 'win32') return `\\\\.\\pipe\\supercode-${hash}`;
+  if (Buffer.byteLength(inside) <= 100) return inside;
+  return join('/tmp', `supercode-machine-${typeof process.getuid === 'function' ? process.getuid() : 'user'}`, `${hash}.sock`);
+}
+
+/** One `harness.v1` call to this machine's daemon: a hello each way, the `node` stream, one request, its answer. */
+export function daemonCall(method, params, { env = process.env, timeoutMs = 15_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const socket = connect(daemonSocket(env));
+    let buffer = Buffer.alloc(0), phase = 'hello', text = '';
+    const done = (error, value) => { clearTimeout(timer); socket.destroy(); error ? reject(error) : resolve(value); };
+    const timer = setTimeout(() => done(new Error(`this machine's daemon did not answer ${method} within ${timeoutMs / 1000} s`)), timeoutMs);
+    const send = (value) => { const bytes = Buffer.from(JSON.stringify(value)); const head = Buffer.alloc(4); head.writeUInt32BE(bytes.length, 0); socket.write(Buffer.concat([head, bytes])); };
+    socket.on('error', (error) => done(new Error(`no machine daemon is answering (${error.message}); run \`supercode teams machine start\``)));
+    socket.on('close', () => done(new Error('the daemon\'s socket closed before it answered')));
+    socket.on('connect', () => send({ p: 'supercode-machine/1', nv: 3 }));
+    socket.on('data', (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      while (buffer.length >= 4 && buffer.length >= 4 + buffer.readUInt32BE(0)) {
+        const frame = JSON.parse(buffer.subarray(4, 4 + buffer.readUInt32BE(0)).toString('utf8'));
+        buffer = buffer.subarray(4 + buffer.readUInt32BE(0));
+        if (phase === 'hello') {
+          if (frame.error) return done(new Error(frame.error));
+          phase = 'open';
+          send({ ch: 1, t: 'open', name: 'node', params: {} });
+          continue;
+        }
+        if (frame.t === 'ping') { send({ ch: 0, t: 'pong' }); continue; }
+        if (frame.ch !== 1) continue;
+        if (frame.t === 'close') return done(new Error(`the daemon refused: ${frame.reason ?? 'closed'}`));
+        if (frame.t === 'opened') { send({ ch: 1, t: 'data', d: `${JSON.stringify({ id: 1, method, params })}\n` }); continue; }
+        if (frame.t !== 'data') continue;
+        text += frame.d;
+        for (let end; (end = text.indexOf('\n')) >= 0;) {
+          const line = text.slice(0, end); text = text.slice(end + 1);
+          let message = null; try { message = JSON.parse(line); } catch { continue; }
+          if (message?.id !== 1) continue;
+          return message.error ? done(new Error(message.error.message ?? 'the daemon refused')) : done(null, message.result);
+        }
+      }
+    });
+  });
+}
 
 /** File one alarm mail for each address. Answers what was filed and the first failure, if any. */
-export function fileAlarm({ machine, env = process.env, to, key, subject, body }) {
+export async function fileAlarm({ machine, env = process.env, to, key, subject, body }) {
   const filed = [];
   let error = null;
   for (const address of to) {
-    const request = { from: `sc:${machine}:operator:machine-health`, from_name: 'Machine health', to: address, id: `${key}-${address}`, subject, body, wake: true };
-    const done = spawnSync(env.SUPERCODE_BIN || 'supercode', ['message', 'file'], { env, input: JSON.stringify(request), encoding: 'utf8', timeout: 10_000, windowsHide: true, shell: process.platform === 'win32' });
-    let answer = null; try { answer = JSON.parse(String(done.stdout ?? '').trim().split('\n').at(-1)); } catch { /* none */ }
+    let answer = null;
+    try { answer = await daemonCall('harness.v1.mail.file', { from: `sc:${machine}:operator:machine-health`, from_name: 'Machine health', to: address, id: `${key}-${address}`, subject, body, wake: true }, { env }); }
+    catch (failure) { error ??= `mail to ${address} was not filed: ${failure.message}`; continue; }
     if (answer?.code === 0) filed.push({ to: address, id: answer.message_id });
-    else error ??= `mail to ${address} was not filed: ${answer?.text || String(done.stderr ?? '').trim().slice(-300) || done.error?.message || `exit ${done.status}`}`;
+    else error ??= `mail to ${address} was not filed: ${answer?.text ?? 'the daemon answered nothing readable'}`;
   }
   return { filed, error };
 }

package/lib/probe.mjs

@@ -184,7 +184,7 @@ export class Probe {
     // The reading is written first; the mail is filed after it, and what the filing did is written beside it.
     writeAtomic(this.f.latest, snapshot);
     if (mail && to.length) {
-      const result = fileAlarm({ machine: this.machine, env: this.env, to, key: `health-${this.machine}-${now}`, subject: mail.subject, body: mail.body });
+      const result = await fileAlarm({ machine: this.machine, env: this.env, to, key: `health-${this.machine}-${now}`, subject: mail.subject, body: mail.body });
       this.lastMail = { at: new Date(now).toISOString(), filed: result.filed.length, to: result.filed.map((f) => f.to), error: result.error };
       if (result.error) this.log(result.error);
       snapshot.mail = this.lastMail;

package/package.json

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