@volter/teams 0.1.39 → 0.1.41

package/channel.mjs

@@ -265,8 +265,8 @@ export class Channel extends EventEmitter {
     return this;
   }
 
-  /** Open a named stream; resolves once the peer accepts it, rejects if refused. */
-  open(name, params = {}) {
+  /** Open a named stream; resolves once the peer accepts it, rejects if refused or unanswered within `timeoutMs`. */
+  open(name, params = {}, { timeoutMs = HANDSHAKE_TIMEOUT_MS } = {}) {
     // A closed connection refuses at once rather than waiting out the handshake bound.
     if (this.closed) return Promise.reject(new Error(`${name} refused: connection closed`));
     const id = this._nextStream;
@@ -278,8 +278,8 @@ export class Channel extends EventEmitter {
       const timer = setTimeout(() => {
         stream.off('opened', onOpened); stream.off('close', onClosed);
         this._streams.delete(id);
-        reject(new Error(`${name} did not open within ${HANDSHAKE_TIMEOUT_MS} ms`));
-      }, HANDSHAKE_TIMEOUT_MS);
+        reject(new Error(`${name} did not open within ${timeoutMs} ms`));
+      }, timeoutMs);
       timer.unref?.();
       const onOpened = () => { clearTimeout(timer); stream.off('close', onClosed); resolve(stream); };
       const onClosed = (reason) => { clearTimeout(timer); stream.off('opened', onOpened); reject(new Error(`${name} refused: ${reason ?? 'closed'}`)); };

package/machine-core.mjs

@@ -89,6 +89,19 @@ export class MachineCore extends EventEmitter {
     ensureSocketDirectory(this.socketPath);
     await clearStaleSocket(this.socketPath);
     await this.beforeListen();
+    try { await this.#listen(); } catch (error) {
+      // What beforeListen started (a product's children) goes with the start that failed, or it outlives this daemon.
+      await this.afterStop().catch(() => {});
+      throw error;
+    }
+    if (this.link) {
+      await this.refreshLinkConfiguration().catch((error) => this.emit('link', { event: 'configuration-failed', error: error.message }));
+      this.#connectLink();
+    }
+    return this.socketPath;
+  }
+
+  async #listen() {
     this.server = createServer((socket) => this.#accept(socket));
     // A Unix socket is bound under a name of this daemon's own and then renamed into place: Node unlinks the name it
     // bound when the server closes, and that name must never be the shared path, which a later daemon may serve from a
@@ -109,15 +122,25 @@ export class MachineCore extends EventEmitter {
     this.address = this.socketPath;
     writeJson(this.p.machine, { pid: process.pid, id: this.id, socket: this.socketPath, startedAt: Date.now(), version: MACHINE_VERSION, protocol: NODE_PROTOCOL, floor: this.floor, server: this.link?.server ?? null });
     this.emit('listening', this.socketPath);
-    if (this.link) {
-      await this.refreshLinkConfiguration().catch((error) => this.emit('link', { event: 'configuration-failed', error: error.message }));
-      this.#connectLink();
+    // The socket check at start has a gap (a daemon restarting has no socket for a moment), so two daemons can each
+    // start; the later rename wins the path and the other serves nobody while its children (a mail watcher that types
+    // waiting turns among them) run on beside the winner's. A daemon whose path now names another daemon's socket
+    // says so once; a daemon run on its own stops on it.
+    if (!isNamedPipe(this.socketPath)) {
+      this.socketWatch = setInterval(() => {
+        let inode = null;
+        try { inode = statSync(this.socketPath).ino; } catch { return; }
+        if (inode === this.socketInode) return;
+        clearInterval(this.socketWatch); this.socketWatch = null;
+        this.emit('superseded', this.socketPath);
+      }, SOCKET_WATCH_MS);
+      this.socketWatch.unref?.();
     }
-    return this.socketPath;
   }
 
   async stop() {
     this.stopping = true;
+    if (this.socketWatch) { clearInterval(this.socketWatch); this.socketWatch = null; }
     if (this.linkTimer) { clearTimeout(this.linkTimer); this.linkTimer = null; }
     // A close frame, so the server sees a machine that left rather than one that vanished.
     try { this.linkSocket?.close(1000, 'machine stopped'); } catch { this.linkSocket?.terminate(); }
@@ -408,6 +431,8 @@ export class MachineCore extends EventEmitter {
 
 }
 
+const SOCKET_WATCH_MS = 5_000;
+
 async function clearStaleSocket(path) {
   // A named pipe has no file to leave behind: only a live daemon holds its name.
   if (!isNamedPipe(path) && !existsSync(path)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "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",