@volter/teams 0.2.48 → 0.2.50

package/board-owner.mjs

@@ -16,7 +16,7 @@
 //               cwd      the caller's working directory, against which a path it names is read
 //               stdin    the caller's standard input, when it names `-` as a file (else null)
 //   answer:   one JSON line  { code, stdout, stderr }
-import { realpathSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { connect } from 'node:net';
 import { join, resolve } from 'node:path';
 
@@ -55,12 +55,40 @@ export function unansweredText(answer, what) {
 }
 
 /**
- * Send one verb to the owner of the home at `root`: answers `{ code, stdout, stderr }`. A home whose owner is not
- * running answers that, with what starts it; nothing else runs the verb.
+ * How long a verb waits for an absent owner to come back. An owner stops when a newer orchestrator is installed under
+ * it, and its keeper starts the new one ten seconds later (the Open Autonomy kit's keeper/start.ts: "the board returns
+ * in 10 s"); the new owner answers within a second of starting. Three times that restart.
  */
-export function askBoardOwner(root, request) {
+export const OWNER_RETURN_MS = 30_000;
+const OWNER_RETRY_MS = 200;
+
+/**
+ * Send one verb to the owner of the home at `root`: answers `{ code, stdout, stderr }`. Nothing else runs the verb.
+ * A home whose owner is not answering, and has had one (its lock `<home>/board.lock` is there), is an owner between
+ * two runs: the connection is tried again until the owner is back, for `waitMs` at most, and the verb is sent once,
+ * to the owner that took the connection. Only then, or at once in a home no owner ever held, is the answer that the
+ * home has no running owner, with what starts it.
+ */
+export async function askBoardOwner(root, request, { waitMs = OWNER_RETURN_MS } = {}) {
   let path;
-  try { path = boardOwnerSocket(root); } catch (error) { return Promise.resolve({ code: 1, stdout: '', stderr: `${error.message}\n` }); }
+  try { path = boardOwnerSocket(root); } catch (error) { return { code: 1, stdout: '', stderr: `${error.message}
+` }; }
+  const began = Date.now();
+  for (;;) {
+    const answer = await askOnce(path, root, request);
+    if (!answer.down) return answer;
+    const waited = Date.now() - began;
+    const held = existsSync(join(boardHome(root), 'board.lock'));
+    if (!held || waited >= waitMs) {
+      const none = held && waitMs > 0 ? `, and none came back within ${Math.round(waited / 1000)} seconds` : '';
+      return { code: 1, stdout: '', stderr: `the boards of ${root} have no running owner${none}: \`supercode workflow serve --root ${root}\` is it (an install's keeper runs it)\n` };
+    }
+    await new Promise((again) => setTimeout(again, Math.min(OWNER_RETRY_MS, waitMs - waited)));
+  }
+}
+
+/** One connection to the owner's socket: its answer, or `{ down: true }` when nothing is listening there (nothing sent). */
+function askOnce(path, root, request) {
   return new Promise((done) => {
     let answer = '';
     let settled = false;
@@ -81,12 +109,10 @@ export function askBoardOwner(root, request) {
       socket.end();
       try { finish(JSON.parse(answer.slice(0, end))); } catch { lost(`the board owner of ${root} answered nothing readable\n`); }
     });
-    socket.on('close', () => lost(`the board owner of ${root} closed the call before answering\n`));
     socket.on('error', (error) => {
-      const down = !sent && ['ENOENT', 'ECONNREFUSED'].includes(error.code);
-      lost(down
-        ? `the boards of ${root} have no running owner: \`supercode workflow serve --root ${root}\` is it (an install's keeper runs it)\n`
-        : sent ? `the board owner of ${root} dropped the call after it was sent: ${error.message}\n` : `the board owner of ${root} could not be reached: ${error.message}\n`);
+      if (!sent && ['ENOENT', 'ECONNREFUSED'].includes(error.code)) return finish({ down: true });
+      lost(sent ? `the board owner of ${root} dropped the call after it was sent: ${error.message}\n` : `the board owner of ${root} could not be reached: ${error.message}\n`);
     });
+    socket.on('close', () => lost(`the board owner of ${root} closed the call before answering\n`));
   });
 }

package/home.mjs

@@ -5,6 +5,7 @@
 //   machine.key / machine.pub   the host key; it signs `describe`, nothing else
 //   machine.sock                the local door: owner-only, the OS user is the caller
 //   machine.json                the running daemon: pid, key id, socket, linked server
+//   machine-link.json           that daemon's link to its server as it is now: up, down or replaced, and since when
 //   launches.jsonl              launch key → pane contextKey
 //   log.jsonl                   hash-chained accountability, no bodies
 //   log.<ts>.jsonl              its rotations, oldest pruned past `logKeep`
@@ -66,6 +67,7 @@ export function ensureSocketDirectory(socketPath) {
 export const paths = (home) => ({
   machineKey: join(home, 'machine'),
   machine: join(home, 'machine.json'),
+  link: join(home, 'machine-link.json'),
   socket: machineSocketPath(home),
   launches: join(home, 'launches.jsonl'),
   log: join(home, 'log.jsonl'),

package/machine-core.mjs

@@ -98,6 +98,7 @@ export class MachineCore extends EventEmitter {
     }
     await this.afterListen();
     if (this.link) {
+      this.#publishLink('down', null);
       await this.refreshLinkConfiguration().catch((error) => this.emit('link', { event: 'configuration-failed', error: error.message }));
       this.#connectLink();
     }
@@ -157,6 +158,7 @@ export class MachineCore extends EventEmitter {
       try { if (statSync(this.socketPath).ino === this.socketInode) rmSync(this.socketPath, { force: true }); } catch { /* already gone */ }
     }
     try { if (JSON.parse(readFileSync(this.p.machine, 'utf8')).pid === process.pid) rmSync(this.p.machine); } catch { /* absent or unreadable */ }
+    try { if (JSON.parse(readFileSync(this.p.link, 'utf8')).pid === process.pid) rmSync(this.p.link); } catch { /* absent or unreadable */ }
   }
 
   /** Before the connections close: a product finishes or abandons what is in flight. */
@@ -164,6 +166,18 @@ export class MachineCore extends EventEmitter {
 
   // ---- the server link ----------------------------------------------------
 
+  /**
+   * The link as it is now, in a file beside the machine record (machine-link.json): `state` up, down or replaced, and
+   * since when. The record's `server` says only which server this daemon was started for; whether it reaches that
+   * server is read here, by what runs outside this process (an upgrade's activation watch, the service's next start),
+   * because a daemon that answers its socket with no link is unreachable to everything remote.
+   */
+  #publishLink(state, error) {
+    if (this.linkPublished?.state === state) return;
+    this.linkPublished = { pid: process.pid, server: this.link?.server ?? null, state, since_ms: Date.now(), error: error ?? null };
+    try { writeJson(this.p.link, this.linkPublished); } catch { /* a reading for others; the link itself is unaffected */ }
+  }
+
   /** Re-read the machine's custodian and grants from the server. */
   async refreshLinkConfiguration() {
     const configuration = await this.link.configuration();
@@ -187,6 +201,7 @@ export class MachineCore extends EventEmitter {
       if (settled) return;
       settled = true;
       if (this.linkSocket === socket) { this.linkSocket = null; this.linkChannel = null; }
+      if (!this.linkReplaced) this.#publishLink('down', error?.message ?? null);
       this.emit('link', { event: 'dropped', error: error?.message ?? null });
       this.#retryLink();
     };
@@ -198,6 +213,7 @@ export class MachineCore extends EventEmitter {
         channel.on('stream', (stream, accept, refuse) => { void this.#onLinkStream(channel, stream, accept, refuse); });
         channel.on('close', () => dropped(null));
         channel.on('error', () => {});
+        this.#publishLink('up', null);
         this.emit('link', { event: 'up', server });
       } catch (error) { socket.terminate(); dropped(error); }
     });
@@ -218,6 +234,7 @@ export class MachineCore extends EventEmitter {
       // this one stops and says so.
       if (String(reason ?? '') === 'replaced') {
         this.linkReplaced = true;
+        this.#publishLink('replaced', 'another connector for this machine took over its link');
         this.emit('link', { event: 'replaced', error: 'another connector for this machine took over its link; this one stopped linking' });
       }
       dropped(null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "type": "module",
   "description": "Volter Teams, the neutral team plane: machine identity and daemon core, the local door and server link, admission from machine grants, product doors, and the Teams server's neutral routes (company RFC 0008).",
   "license": "MIT",