@volter/teams 0.2.49 → 0.2.51

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.49",
+  "version": "0.2.51",
   "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",

package/session-follow.mjs

@@ -2,6 +2,11 @@
 // the hosted viewer uses, exported so a workplace that draws the session itself (RH2's Conversation, supercode-ui in
 // its own tree) reads and labels it the same way. No imports: it runs as the viewer's own module and in a host's bundle.
 
+// A signal that aborts `ms` from now, for use inside AbortSignal.any(). Its timer holds its controller, so it fires
+// whatever the garbage collector does. AbortSignal.timeout() inside AbortSignal.any() does not on Node 23.9: the timeout
+// signal is collected, the combined signal never aborts, and a request to a server that went quiet never ends.
+const timeoutSignal=ms=>{const controller=new AbortController(),timer=setTimeout(()=>controller.abort(new DOMException('The operation was aborted due to timeout','TimeoutError')),ms);timer.unref?.();return controller.signal;};
+
 /**
  * Follow one session: its snapshot read whole (`/messages?tail=`, a busy session's is over the follow stream's 1 MB
  * buffer), then its follow stream from that snapshot's cursor, each change meaning "read again". The stream ends when
@@ -25,7 +30,7 @@ export function followTeamSession({ origin, teamId, sessionId, token, tail = 300
       let snapshot;
       do {
         requested = false;
-        const response = await fetchImpl(`${base}/messages?tail=${tail}`, { headers: await headers(), signal: AbortSignal.any([controller.signal, AbortSignal.timeout(15000)]) });
+        const response = await fetchImpl(`${base}/messages?tail=${tail}`, { headers: await headers(), signal: AbortSignal.any([controller.signal, timeoutSignal(15000)]) });
         if (!response.ok) throw failure('read', response.status, `reading the session failed (${response.status})`);
         const body = await response.json();
         if (controller.signal.aborted) throw new DOMException('Session follow stopped', 'AbortError');