@volter/teams 0.2.30 → 0.2.32

package/board-owner.mjs

@@ -46,6 +46,14 @@ export const BOARD_OPERATION_VERBS = new Set(['serve', 'daemon', 'dispatch', 'in
 export const CALLER_FACTS = ['SUPERCODE_AGENT_ID', 'SUPERCODE_AUTOMATION', 'SUPERCODE_CONTEXT', 'HERMES_PROFILE', 'USER', 'SUPERCODE_CALLER', 'SUPERCODE_RUN_LAUNCH'];
 export const callerFacts = (env = process.env) => Object.fromEntries(CALLER_FACTS.filter((key) => env[key]).map((key) => [key, env[key]]));
 
+/**
+ * What a caller says of an answer marked `unanswered` (the owner took the request and the call ended with no answer):
+ * the outcome is unknown, and the card is read before the verb is run again. `what` names the verb or tool.
+ */
+export function unansweredText(answer, what) {
+  return `${String(answer.stderr ?? '').trim() || 'the board owner gave no answer'}; whether ${what} ran is unknown: read the card with \`supercode workflow show <id>\` before running it again\n`;
+}
+
 /**
  * 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.
@@ -56,25 +64,29 @@ export function askBoardOwner(root, request) {
   return new Promise((done) => {
     let answer = '';
     let settled = false;
+    // once the request is written the owner may have run the verb: a failure after that is `unanswered` (whether it
+    // ran is unknown), never a plain failure a caller would take as "nothing happened" and run again
+    let sent = false;
     const finish = (value) => { if (!settled) { settled = true; done(value); } };
+    const lost = (stderr) => finish({ code: 1, stdout: '', stderr, ...(sent ? { unanswered: true } : {}) });
     const socket = connect(path);
     socket.setEncoding('utf8');
     // The request is one line, and the connection stays open both ways until the answer's line has come: an answer that
     // takes its time (a Teams lookup, a reread home) is never lost to a closed side.
-    socket.on('connect', () => socket.write(`${JSON.stringify({ v: 1, ...request })}\n`));
+    socket.on('connect', () => { sent = true; socket.write(`${JSON.stringify({ v: 1, ...request })}\n`); });
     socket.on('data', (chunk) => {
       answer += chunk;
       const end = answer.indexOf('\n');
       if (end < 0) return;
       socket.end();
-      try { finish(JSON.parse(answer.slice(0, end))); } catch { finish({ code: 1, stdout: '', stderr: `the board owner of ${root} answered nothing readable\n` }); }
+      try { finish(JSON.parse(answer.slice(0, end))); } catch { lost(`the board owner of ${root} answered nothing readable\n`); }
     });
-    socket.on('close', () => finish({ code: 1, stdout: '', stderr: `the board owner of ${root} closed the call before answering\n` }));
+    socket.on('close', () => lost(`the board owner of ${root} closed the call before answering\n`));
     socket.on('error', (error) => {
-      const down = ['ENOENT', 'ECONNREFUSED'].includes(error.code);
-      finish({ code: 1, stdout: '', stderr: down
+      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`
-        : `the board owner of ${root} could not be reached: ${error.message}\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`);
     });
   });
 }

package/machine-core.mjs

@@ -257,7 +257,13 @@ export class MachineCore extends EventEmitter {
   // ---- connections ---------------------------------------------------------
 
   /** The local door: whoever opened the owner-only socket is this OS user. */
-  async #accept(socket) {
+  #accept(socket) { return this.acceptLocal(socket); }
+
+  /**
+   * A local connection: one the socket accepted, or one made inside this daemon (`facts` mark it: the app door's
+   * relayed pages are `{ appDoor: true }`, which no client can claim, as it never reaches this through the socket).
+   */
+  async acceptLocal(socket, facts = {}) {
     let channel;
     try {
       channel = await Channel.accept(socket, { floor: this.floor });
@@ -266,8 +272,9 @@ export class MachineCore extends EventEmitter {
       return;
     }
     const index = this.nextConnection++;
-    // The socket stays on the entry: who is on its other end is read from the kernel, not from what the client says.
-    const entry = { channel, admitted: LOCAL_OPERATOR, principal: 'local', socket };
+    // Who is on its other end is what the client says (its claim), held to the daemon's live-session map; the socket is
+    // this user's alone (docs/architecture/overview.md, "Who is calling").
+    const entry = { ...facts, channel, admitted: LOCAL_OPERATOR, principal: 'local', socket };
     this.connections.set(index, entry);
     channel.on('stream', (stream, accept, refuse) => this.#routeStream(index, entry, stream, accept, refuse));
     channel.on('close', () => { this.connections.delete(index); this.connectionClosed(index); });

package/package.json

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