@volter/supercode-teams 0.2.94 → 0.2.95

package/bin/workspace/upgrade-watch.mjs

@@ -0,0 +1,26 @@
+// 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';
+import { fileURLToPath } from 'node:url';
+
+const CODE_WATCH_MS = 60_000;
+
+const stamp = (file) => {
+  try { const s = statSync(file); return `${s.ino}:${s.size}:${s.mtimeMs}`; } catch { return null; }
+};
+
+/** Call `onChange(file)` once, the first time one of `files` is replaced; returns a function that stops watching. */
+export function watchCodeChange(files, onChange) {
+  const watched = files.filter(Boolean).map((file) => (file instanceof URL ? fileURLToPath(file) : String(file)));
+  const first = new Map(watched.map((file) => [file, stamp(file)]));
+  const timer = setInterval(() => {
+    // A file that is missing for a moment (an installer between removing and writing it) is not yet a change.
+    const changed = watched.find((file) => { const now = stamp(file); return now !== null && now !== first.get(file); });
+    if (!changed) return;
+    clearInterval(timer);
+    onChange(changed);
+  }, CODE_WATCH_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}

package/bin/workspace.mjs

@@ -18,6 +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 { volterDeviceSignIn } from './workspace/volter-device.mjs';
 import { loginSummary, signInToTeams } from './workspace/volter-login.mjs';
 import { readSharedSignIn, signOut } from '@volter/identity';
@@ -737,6 +738,23 @@ async function connectorCommand(verb, { flags, rest, output, client, context, te
     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); };
     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). On Windows the service runs a per-version copy, so what an upgrade replaces is the
+    // `supercode` on PATH, and the move is the install that re-pins the service (it stops this connector and starts
+    // the new copy). Elsewhere it stops and exits non-zero, which every service manager here restarts.
+    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`);
+        if (process.platform === 'win32') {
+          spawn('supercode', ['teams', 'connect', '--install', '--context', contextName, '--cwd', path], { shell: true, detached: true, stdio: 'ignore', windowsHide: true }).unref();
+          return;
+        }
+        process.exitCode = 75;
+        void stopConnector?.();
+      });
+    }
     await new Promise(resolveStop => { let stopped = false; stopConnector = async () => { if (stopped) return; stopped = true; await stopAll(); resolveStop(); }; for (const signal of ['SIGINT', 'SIGTERM', ...(process.platform === 'win32' ? ['SIGHUP', 'SIGBREAK'] : [])]) process.once(signal, stopConnector); });
     return;
   }

package/package.json

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