@volter/teams 0.1.37 → 0.1.39

package/channel.mjs

@@ -15,8 +15,9 @@
 import { EventEmitter } from 'node:events';
 
 const PROTOCOL = 'supercode-machine/1';
-/** The door vocabulary version. It grows; the framing under PROTOCOL never changes. */
-export const NODE_PROTOCOL = 2;
+/** The door vocabulary version. It grows; the framing under PROTOCOL never changes. 3: a `mail` turn carries a
+ *  `turn_key`, and the machine types each key once however often it is opened. */
+export const NODE_PROTOCOL = 3;
 const MAX_FRAME = 8 * 1024 * 1024;
 
 /** Reads u32-length-prefixed frames from a socket. */

package/machine-core.mjs

@@ -8,7 +8,8 @@
 // It decides nothing on anyone's behalf. Every act is logged.
 import { createServer, connect as netConnect } from 'node:net';
 import { EventEmitter } from 'node:events';
-import { existsSync, mkdirSync, rmSync, chmodSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, chmodSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { WebSocket, createWebSocketStream } from 'ws';
 import { Channel, NODE_PROTOCOL } from './channel.mjs';
@@ -89,13 +90,22 @@ export class MachineCore extends EventEmitter {
     await clearStaleSocket(this.socketPath);
     await this.beforeListen();
     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
+    // file of its own (a daemon stopping later deleted the serving daemon's socket and cut it off).
+    const bindPath = isNamedPipe(this.socketPath) ? this.socketPath : join(dirname(this.socketPath), `.m${process.pid.toString(36)}`);
+    if (bindPath !== this.socketPath) rmSync(bindPath, { force: true });
     await new Promise((resolveListen, reject) => {
       this.server.once('error', reject);
-      this.server.listen(this.socketPath, () => { this.server.off('error', reject); resolveListen(); });
+      this.server.listen(bindPath, () => { this.server.off('error', reject); resolveListen(); });
     });
     // Owner-only: the socket is the local door, and whoever opens it is this OS user. A named pipe's default
     // access already admits only its owner (and SYSTEM and Administrators) to connect.
-    if (!isNamedPipe(this.socketPath)) chmodSync(this.socketPath, 0o600);
+    if (!isNamedPipe(this.socketPath)) {
+      chmodSync(bindPath, 0o600);
+      this.socketInode = statSync(bindPath).ino;
+      renameSync(bindPath, this.socketPath);
+    }
     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);
@@ -116,8 +126,11 @@ export class MachineCore extends EventEmitter {
     for (const { channel } of this.connections.values()) channel.close();
     this.server?.close();
     await this.afterStop();
-    if (!isNamedPipe(this.socketPath)) rmSync(this.socketPath, { force: true });
-    if (existsSync(this.p.machine)) rmSync(this.p.machine);
+    // Only this daemon's own socket and record: a daemon that has since taken the path over keeps them.
+    if (!isNamedPipe(this.socketPath) && this.socketInode !== undefined) {
+      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 */ }
   }
 
   /** Before the connections close: a product finishes or abandons what is in flight. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "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/server/machine-link.mjs

@@ -14,6 +14,7 @@
 // A delegated caller (./delegated.mjs) holds no Teams credential: its verified token, when it names exactly a surface
 // the machine's custodian published to that workplace (./publications.mjs), becomes one machine grant on that target
 // and the caps the token names, expiring with the token; its channel closes then, or when the surface is unpublished.
+import { randomUUID } from 'node:crypto';
 import { Channel } from '../channel.mjs';
 import { bearer } from './auth.mjs';
 import { delegatedAccessOf, delegatedPrincipal, delegatedSessionOf, looksDelegated, surfaceCaps } from './delegated.mjs';
@@ -306,6 +307,8 @@ async function acceptLink(api, teamId, machineId, duplex, closeSocket) {
 }
 
 const LINK_WAIT_MS = 10_000;
+/** How long a typed line is retried on a machine that is linked but too loaded to open its stream. */
+const TURN_RETRY_MS = 120_000;
 
 /** The machine's live link, waiting up to `ms` for one that is relinking. */
 async function linkWithin(api, linkKey, ms) {
@@ -339,15 +342,24 @@ async function acceptChannel(api, auth, machineId, duplex, closeSocket) {
     entry.claim = claim;
     // A machine relinks within seconds of this server restarting (a deploy drops every link): a stream waits for its
     // link that long, and retries once on a link that closed under it, rather than refusing a message mid-relink.
+    // A line typed into a session is a person's words: a machine too loaded to answer the open in time is waited on,
+    // not refused, and every attempt carries one key so the machine types the line once however many reach it (an
+    // open that timed out here can still be accepted there). A machine below vocabulary 3 does not know the key and
+    // keeps the single attempt.
+    const turn = stream.name === 'mail' && stream.params?.request?.op === 'turn';
+    const params = turn ? { ...stream.params, request: { turn_key: `tk_${randomUUID()}`, ...stream.params.request } } : (stream.params ?? {});
+    const turnDeadline = Date.now() + TURN_RETRY_MS;
     let upstream;
     for (let attempt = 0; ; attempt += 1) {
       const link = await linkWithin(api, key(auth.team_id, machineId), LINK_WAIT_MS);
       if (!link) return refuse('machine_offline: the machine is not linked to this server');
       try {
-        upstream = await link.channel.open(stream.name, { ...(stream.params ?? {}), _admitted: claim });
+        upstream = await link.channel.open(stream.name, { ...params, _admitted: claim });
         break;
       } catch (error) {
         if (attempt === 0 && link.channel.closed) continue;
+        const keyed = turn && (link.channel.peer?.nv ?? 0) >= 3;
+        if (keyed && !stream.closed && Date.now() < turnDeadline && (link.channel.closed || /did not open within/.test(error.message))) continue;
         return refuse(error.message.replace(/^[a-z]+ refused: /, ''));
       }
     }