@volter/supercode-teams 0.2.95 → 0.2.97

package/bin/workspace/upgrade-watch.mjs

@@ -1,7 +1,9 @@
 // An upgrade replaces the code a long-running connector runs (its native binary, this package) under it. Its readers
 // go on answering from the code they loaded, so every reading it serves is the old version's until something
-// restarts it. This watches the files that code came from and says, once, when one of them changed.
-import { statSync } from 'node:fs';
+// restarts it. This watches the files that code came from and says, once, when one of them changed; and it lets the
+// service's connector take back the socket from a linkless daemon started while it was between restarts.
+import { readFileSync, statSync } from 'node:fs';
+import { connect } from 'node:net';
 import { fileURLToPath } from 'node:url';
 
 const CODE_WATCH_MS = 60_000;
@@ -24,3 +26,27 @@ export function watchCodeChange(files, onChange) {
   timer.unref?.();
   return () => clearInterval(timer);
 }
+
+const alive = (pid) => { try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
+
+/**
+ * Stop the daemon `record` (its machine.json) names when it has no server link (`server: null`, a standalone
+ * `machine start`) and is not this process, and wait up to 15 s for it to go. A linked daemon is left alone.
+ */
+export async function retireLinklessDaemon(record) {
+  let daemon;
+  try { daemon = JSON.parse(readFileSync(record, 'utf8')); } catch { return; }
+  const pid = Number(daemon?.pid);
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid || daemon.server || !alive(pid)) return;
+  // The record outlives a crash and its pid can be reused: only a daemon that answers on the socket is stopped.
+  const answers = await new Promise((resolve) => {
+    if (typeof daemon.socket !== 'string') return resolve(false);
+    const probe = connect(daemon.socket);
+    probe.once('connect', () => { probe.destroy(); resolve(true); });
+    probe.once('error', () => resolve(false));
+  });
+  if (!answers) return;
+  process.stderr.write(`supercode teams: a machine daemon with no server link (pid ${pid}) holds this machine's socket; asking it to stop\n`);
+  try { process.kill(pid, 'SIGTERM'); } catch { return; }
+  for (let waited = 0; waited < 15_000 && alive(pid); waited += 250) await new Promise((resolve) => setTimeout(resolve, 250));
+}

package/bin/workspace.mjs

@@ -18,7 +18,7 @@ import { loadOrCreateKeyPair, publicKeyId } from '@volter/teams/identity';
 import { duration, parseArgs, positiveInteger, requireArgs, usage } from './workspace/args.mjs';
 import { reserveArtifactDirectory, reserveProtected, writeProtected } from './workspace/files.mjs';
 import { acquireLifecycle, activeSocket, lifecycleHeld, requestStop } from './workspace/lifecycle.mjs';
-import { watchCodeChange } from './workspace/upgrade-watch.mjs';
+import { retireLinklessDaemon, watchCodeChange } from './workspace/upgrade-watch.mjs';
 import { volterDeviceSignIn } from './workspace/volter-device.mjs';
 import { loginSummary, signInToTeams } from './workspace/volter-login.mjs';
 import { readSharedSignIn, signOut } from '@volter/identity';
@@ -736,6 +736,34 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     // The connector is the service's daemon and keeps serving; a daemon that took its socket path is the one to stop.
     machine.on('superseded', (path) => process.stderr.write(`supercode teams: another machine daemon replaced this connector's socket at ${path}; stop it (supercode teams status)\n`));
     const stopAll = async () => { await machine.stop().catch(() => {}); await connector.stop(); await core.close(); await largeCore.close(); await slowCore.close(); await liveCore.close(); await lifecycle.close(); state.update(current => current ? ({ ...current, process: undefined }) : null); };
+    // A daemon with no server link holding the socket is a session's auto-start while this service was between
+    // restarts (from a supercode old enough not to wait for the service): it yields to the service's connector, which
+    // otherwise failed on EADDRINUSE at every restart and left this machine unlinked.
+    if (saved.service) await retireLinklessDaemon(paths(daemonHome).machine);
+    try { await connector.start({ roots: () => saved.roots }); await machine.start(); } catch (error) { await stopAll(); throw error; }
+    output({ version: 1, context: scope(context), data: { machine: saved.machine, source: saved.source, roots: saved.roots.map(({ path: _path, ...item }) => item), socket: machine.socketPath, foreground: true } });
+    // Run by a service, the connector moves to an upgrade on its own: its readers would otherwise answer from the code
+    // they loaded until something restarted it (after 0.5.51 this Mac's went on reading a Codex turn waiting on an
+    // approval as busy). The move is the install, run by the upgraded CLI, because an upgrade can change the service
+    // unit too (a launchd job without ProcessType ran at background priority and missed discovery's bound): it rewrites
+    // a changed unit and restarts this connector under it. It runs in a session of its own, so a service manager
+    // stopping this connector cannot stop it half done. On Windows the service runs a per-version copy, so the upgraded
+    // CLI is the `supercode` on PATH (whose install stops this connector; the task's repeat starts the new copy).
+    // An unchanged unit leaves this connector running, and it then restarts itself: every service manager here
+    // restarts a connector that exits non-zero.
+    if (saved.service) {
+      const shim = process.platform === 'win32' ? (() => { try { return execFileSync('where', ['supercode'], { encoding: 'utf8', windowsHide: true }).split(/\r?\n/).find(Boolean); } catch { return null; } })() : null;
+      watchCodeChange([process.env.SUPERCODE_BIN, new URL('../package.json', import.meta.url), shim], (changed) => {
+        process.stderr.write(`supercode teams: ${changed} changed under this connector (an upgrade); moving to the new code\n`);
+        const cli = process.platform === 'win32' ? 'supercode' : process.env.SUPERCODE_BIN;
+        spawn(cli, ['teams', 'connect', '--install', '--context', contextName, '--cwd', path], { shell: process.platform === 'win32', detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        if (process.platform !== 'win32') setTimeout(() => { process.exitCode = 75; void stopConnector?.(); }, 60_000);
+      });
+    }
+    // A daemon with no server link holding the socket is a session's auto-start while this service was between
+    // restarts (from a supercode old enough not to wait for the service): it yields to the service's connector, which
+    // otherwise failed on EADDRINUSE at every restart and left this machine unlinked.
+    if (saved.service) await retireLinklessDaemon(paths(daemonHome).machine);
     try { await connector.start({ roots: () => saved.roots }); await machine.start(); } catch (error) { await stopAll(); throw error; }
     output({ version: 1, context: scope(context), data: { machine: saved.machine, source: saved.source, roots: saved.roots.map(({ path: _path, ...item }) => item), socket: machine.socketPath, foreground: true } });
     // Run by a service, the connector moves to an upgrade on its own: its readers would otherwise answer from the code

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.95",
+  "version": "0.2.97",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",