@volter/teams 0.2.47 → 0.2.49

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/machine-door.mjs

@@ -13,8 +13,11 @@ export async function openMachine({ machine = null, context = null, env = proces
   // This machine named by its own name is its own daemon, reached over its socket: through the Teams server it waited
   // on the org's machine list and a server channel, and a launch on this box failed whenever the server was rate
   // limited or out of reach (two review resumes, 17:03Z and 17:34Z, retired as never issued).
-  if (!machine.startsWith('mach_') && normalMachineName(machine) === normalMachineName(hostname()) && existsSync(paths(home).socket)) return openLocalMachine(paths(home).socket);
+  // Its own name is the one this home is enrolled under, never the host's: a second machine enrolled from the same host
+  // shares the host name with the first, and one reaching the other by that name must go through the Teams server (its
+  // own socket is its own daemon, which would hand the request back to itself until the caller gave up).
   const supercodeHome = env.SUPERCODE_HOME ?? resolve(home, '..');
+  if (!machine.startsWith('mach_') && normalMachineName(machine) === ownMachineName(supercodeHome) && existsSync(paths(home).socket)) return openLocalMachine(paths(home).socket);
   const contexts = new WorkspaceContexts(supercodeHome);
   const name = context ?? env.SUPERCODE_CONTEXT ?? contexts.read().current;
   if (!name || name === 'local') throw Object.assign(new Error('a remote machine is reached through a Teams context: `supercode teams login …`, then `supercode context use NAME` or --context NAME'), { code: 'invalid_request' });
@@ -50,6 +53,18 @@ export async function openMachine({ machine = null, context = null, env = proces
   return channel;
 }
 
+/** The name this home's machine goes by, in the form mail addresses use: its enrollment's in the home's current
+ *  context, else (an unenrolled machine) the host's. */
+export function ownMachineName(supercodeHome) {
+  let name = hostname();
+  try {
+    const contexts = new WorkspaceContexts(supercodeHome);
+    const doc = contexts.read(), context = doc.contexts[doc.current];
+    name = contexts.connector(context.server_id, context.team_id).read()?.machine?.name || name;
+  } catch { /* an unenrolled machine goes by its host name */ }
+  return normalMachineName(name);
+}
+
 /** A machine name in the form mail addresses use: the short host name, lowercased, with anything outside [a-z0-9_-] as `-`. */
 export function normalMachineName(name) {
   return String(name).split('.')[0].toLowerCase().replace(/[^a-z0-9_-]/g, '-');

package/package.json

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