@oddessentials/agent-guild 0.33.1 → 0.33.2

package/README.md

@@ -337,7 +337,7 @@ Any other tool or script can report agents and its model too. See
   been uninstalled or moved removes itself at the next sign-in. With nvm,
   the package lives in the Node.js version's folder, so uninstalling that
   version counts as uninstalling Agent Guild; a Homebrew Node.js upgrade
-  does not. On macOS and Linux what the entry runs at sign-in, including a
+  or a Snap Node.js refresh does not. On macOS and Linux what the entry runs at sign-in, including a
   missing Node.js, is appended to `manager.log`.
   The entry saves the manager's listening port, including the assigned port
   when started with `AGENT_GUILD_PORT=0`. Enabled entries are updated when

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddessentials/agent-guild",
-  "version": "0.33.1",
+  "version": "0.33.2",
   "description": "Launch and watch AI coding-assistant terminal sessions from one local web page. A bundled session manager owns the terminals so the page can close and reconnect.",
   "license": "MIT",
   "repository": {

package/src/manager/autostart.mjs

@@ -27,8 +27,8 @@
 // an entry whose package script is gone removes itself at sign-in instead
 // of failing there at every sign-in after. A missing Node.js alone keeps
 // the entry: the next manager to start points it at its own. Homebrew's
-// Node.js is named by its opt link, which an upgrade keeps, rather than by
-// the versioned Cellar folder the upgrade deletes.
+// and Snap's Node.js are named by the link an upgrade keeps (opt, current)
+// rather than by the versioned folder the upgrade deletes.
 
 import fs from 'node:fs';
 import os from 'node:os';
@@ -138,19 +138,31 @@ export function posixCommand({ launcher, ...paths }) {
 }
 
 /**
- * Homebrew runs Node.js from `<prefix>/Cellar/<formula>/<version>`, which
- * the next upgrade deletes. `<prefix>/opt/<formula>` follows the formula
- * across upgrades, so it names Node.js instead when it leads to the same file.
+ * Versioned Node.js folders that an upgrade deletes, each with the link that
+ * follows the package across upgrades. Homebrew runs Node.js from
+ * `<prefix>/Cellar/<formula>/<version>`, kept as `<prefix>/opt/<formula>`.
+ * A snap runs it from `<snaps>/<snap>/<revision>`, where `<snaps>` is
+ * `/snap` or `/var/lib/snapd/snap`, kept as `<snaps>/<snap>/current`; snapd
+ * removes old revisions after a refresh.
  */
+const VERSIONED_NODE = [
+  [/^(.+)\/Cellar\/([^/]+)\/[^/]+\/bin\/node$/, (prefix, formula) => `${prefix}/opt/${formula}/bin/node`],
+  [/^(.*\/snap)\/([^/]+)\/x?\d+\/bin\/node$/, (snaps, snap) => `${snaps}/${snap}/current/bin/node`],
+];
+
+/** Names Node.js by the link that survives upgrades, when that link leads to the same file. */
 export function stableExecPath(execPath, realpath = fs.realpathSync) {
-  const match = execPath.match(/^(.+)\/Cellar\/([^/]+)\/[^/]+\/bin\/node$/);
-  if (!match) return execPath;
-  const opt = `${match[1]}/opt/${match[2]}/bin/node`;
-  try {
-    return realpath(opt) === realpath(execPath) ? opt : execPath;
-  } catch {
-    return execPath;
+  for (const [pattern, link] of VERSIONED_NODE) {
+    const match = execPath.match(pattern);
+    if (!match) continue;
+    const stable = link(...match.slice(1));
+    try {
+      return realpath(stable) === realpath(execPath) ? stable : execPath;
+    } catch {
+      return execPath;
+    }
   }
+  return execPath;
 }
 
 const xml = (value) => value.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]);

package/src/manager/command-resolver.mjs

@@ -55,13 +55,15 @@ function candidateGroups(command, env, platform) {
  * Resolve `command` to an absolute path, or return null when it is not
  * installed. Commands that already contain a path separator are checked as-is.
  * `isExecutable` is injectable so tests can simulate another platform.
+ * `onSkip` drops a candidate before that check, without touching the filesystem.
  */
 export function resolveCommand(command, env = process.env, platform = process.platform, {
   isExecutable = (file) => isExecutableFile(file, platform),
+  onSkip = () => false,
 } = {}) {
   if (!command) return null;
   for (const group of candidateGroups(command, env, platform)) {
-    const hit = group.find((c) => isExecutable(c));
+    const hit = group.find((candidate) => !onSkip(candidate) && isExecutable(candidate));
     if (hit) return hit;
   }
   return null;

package/src/manager/environment-probe.mjs

@@ -52,8 +52,8 @@ export function passiveExecutable(file, id, { platform = process.platform, env =
   if (/\/(?:shims|\.nodejs)\//.test(normalized) || /\/(?:mise|asdf|volta)(?:\.exe)?$/.test(normalized)) {
     return { error: 'A version-manager shim was found. Its runtime cannot be checked without activating the manager.' };
   }
-  if (platform === 'win32' && /\/windowsapps\//.test(normalized)) {
-    return { error: 'A Windows execution alias was found. A runtime behind this alias has not been verified.' };
+  if (platform === 'win32' && windowsAlias(normalized)) {
+    return { error: WINDOWS_ALIAS };
   }
   const head = read(real);
   const binary = head[0] === 0x4d && head[1] === 0x5a // PE
@@ -68,22 +68,43 @@ export function passiveExecutable(file, id, { platform = process.platform, env =
   return { error: 'A script launcher was found. Passive detection does not execute unrecognized wrappers.' };
 }
 
+const WINDOWS_ALIAS = 'A Windows execution alias was found. A runtime behind this alias has not been verified.';
+
+function windowsAlias(file) {
+  return /[\\/]windowsapps[\\/]/i.test(file);
+}
+
 // The helper has a second, independent overall deadline in Environment. A
 // timeout here resolves immediately, even if a descendant retains stdout.
-export function runProbe(file, args, { env, cwd, timeoutMs = TIMEOUT_MS, spawnProcess = spawn } = {}) {
+// The kill is recorded for directory cleanup and does not delay this result.
+export function runProbe(file, args, { env, cwd, timeoutMs = TIMEOUT_MS, spawnProcess = spawn, kills = null } = {}) {
   return new Promise((resolve) => {
     let child, timer, size = 0, output = '', settled = false;
     const stop = () => {
       if (!child?.pid) return;
-      if (process.platform === 'win32') killWindowsTree(child.pid);
-      else { try { child.kill('SIGKILL'); } catch { /* already gone */ } }
-      child.stdout?.destroy(); child.stderr?.destroy(); child.unref();
+      const pending = new Promise((done) => {
+        let ended = false;
+        // Keep cleanup alive after the child is unref'd, even if 'close' never arrives.
+        const backup = setTimeout(finishKill, 2000);
+        function finishKill() {
+          if (ended) return;
+          ended = true;
+          clearTimeout(backup);
+          done();
+        }
+        // 'close' waits for the process to end. Do not settle when stdio is only destroyed.
+        child.once('close', finishKill);
+        if (process.platform === 'win32') killWindowsTree(child.pid, finishKill);
+        else { try { child.kill('SIGKILL'); } catch { finishKill(); } }
+      });
+      if (Array.isArray(kills)) kills.push(pending);
+      try { child.stdout?.destroy(); child.stderr?.destroy(); child.unref(); } catch { /* the kill is already recorded */ }
     };
     const finish = (result, kill = false) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      if (kill) stop();
+      if (kill) try { stop(); } catch { /* the probe result still stands */ }
       resolve({ output, ...result });
     };
     try {
@@ -108,17 +129,28 @@ const unavailable = {
   rust: /no default is configured|toolchain .*not installed|could not choose a version|toolchain .*is not installable/i,
 };
 
-export async function scanRuntime(definition, { env, cwd, platform = process.platform, resolve = resolveCommand, inspect = passiveExecutable, run = runProbe } = {}) {
+export async function scanRuntime(definition, { env, cwd, platform = process.platform, resolve = resolveCommand, inspect = passiveExecutable, run = runProbe, kills = null } = {}) {
   const { id, label, command, args, pattern } = definition;
   const base = { id, label, status: 'not_found', version: null, path: null, command, detail: null };
   const one = async (name) => {
-    const file = resolve(name, env, platform);
-    if (!file) return { ...base, command: name };
+    // A Windows execution alias must not be inspected or spawned. A later real binary still wins.
+    let alias = null;
+    const file = resolve(name, env, platform, {
+      onSkip(candidate) {
+        if (platform !== 'win32' || !windowsAlias(candidate)) return false;
+        if (!alias || path.win32.extname(candidate).toLowerCase() === '.exe') alias = candidate;
+        return true;
+      },
+    });
+    if (!file) {
+      if (!alias) return { ...base, command: name };
+      return { ...base, command: name, path: alias, status: 'unavailable', detail: WINDOWS_ALIAS };
+    }
     const row = { ...base, command: name, path: file };
     try {
       const executable = inspect(file, id, { platform, env });
       if (executable.error) return { ...row, status: 'unavailable', detail: executable.error };
-      const result = await run(executable.file, args, { env: { ...probeEnv(env), DOTNET_CLI_HOME: cwd, DOTNET_GENERATE_ASPNET_CERTIFICATE: 'false' }, cwd });
+      const result = await run(executable.file, args, { env: { ...probeEnv(env), DOTNET_CLI_HOME: cwd, DOTNET_GENERATE_ASPNET_CERTIFICATE: 'false' }, cwd, kills });
       if (result.error) return { ...row, status: 'failed', detail: result.error };
       const version = result.code === 0 ? pattern.exec(result.output)?.[1] : null;
       if (version) return { ...row, status: 'ok', version };
@@ -139,7 +171,7 @@ export async function scanRuntime(definition, { env, cwd, platform = process.pla
     try {
       const executable = inspect(row.path, id, { platform, env });
       if (!executable.error) {
-        const result = await run(executable.file, ['--list-runtimes'], { env: { ...probeEnv(env), DOTNET_CLI_HOME: cwd }, cwd });
+        const result = await run(executable.file, ['--list-runtimes'], { env: { ...probeEnv(env), DOTNET_CLI_HOME: cwd }, cwd, kills });
         if (result.code === 0) row.runtimes = result.output.split(/\r?\n/).map((line) => line.match(/^(Microsoft\.[\w.]+) (\d+\.\d+\.\d+(?:-[\w.-]+)?) \[/))
           .filter(Boolean).map((match) => ({ name: match[1], version: match[2] }));
       }
@@ -162,10 +194,31 @@ export function detectTools({ env, platform = process.platform, resolve = resolv
   return tools;
 }
 
+// Windows cannot remove a process's current working directory, and a probe
+// killed at its deadline can still hold that directory. Cleanup must not
+// decide whether the scan succeeded.
+export async function releaseScanDirectory(cwd, kills = [], {
+  chdir = (dir) => process.chdir(dir),
+  remove = fs.rmSync,
+  tmpdir = os.tmpdir,
+} = {}) {
+  await Promise.all(kills).catch(() => {});
+  let temp = '';
+  try { temp = tmpdir(); } catch { /* removal is skipped below */ }
+  try { if (temp) chdir(temp); } catch { /* still try to remove the scan directory */ }
+  if (!cwd || !temp) return;
+  if (path.dirname(cwd) !== path.resolve(temp) || !path.basename(cwd).startsWith('agent-guild-environment-')) return;
+  try {
+    remove(cwd, { recursive: true, force: true, maxRetries: 5, retryDelay: 40 });
+  } catch { /* a leftover lock must not fail the scan */ }
+}
+
 if (process.argv[2] === '--scan-environment' && process.send) {
   // A fresh temporary directory contains no project files. Manager env is
   // retained; no selected shell, project or session is inspected or changed.
   let cwd;
+  let finished = false;
+  const kills = [];
   try {
     cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-guild-environment-'));
     process.chdir(cwd);
@@ -174,16 +227,13 @@ if (process.argv[2] === '--scan-environment' && process.send) {
     // Two batches bound concurrency while giving each runtime its own result.
     for (let i = 0; i < RUNTIMES.length; i += 3) {
       await Promise.all(RUNTIMES.slice(i, i + 3).map(async (definition) => {
-        const runtime = await scanRuntime(definition, { env, cwd });
+        const runtime = await scanRuntime(definition, { env, cwd, kills });
         process.send({ runtime });
       }));
     }
+    finished = true;
   } finally {
-    // Windows cannot remove a process's current working directory.
-    process.chdir(os.tmpdir());
-    if (cwd && path.dirname(cwd) === path.resolve(os.tmpdir()) && path.basename(cwd).startsWith('agent-guild-environment-')) {
-      fs.rmSync(cwd, { recursive: true, force: true });
-    }
+    await releaseScanDirectory(cwd, kills);
   }
-  process.send({ done: true });
+  if (finished) process.send({ done: true });
 }

package/src/manager/environment.mjs

@@ -61,7 +61,11 @@ export class Environment extends EventEmitter {
         if (message?.done) finish();
       });
       run.child.once('error', () => finish('Could not start the environment check.'));
-      run.child.once('exit', () => finish('The environment check stopped before finishing.'));
+      // Let messages already queued win. Exit is a failed check only when a runtime never reported.
+      run.child.once('exit', () => setImmediate(() => {
+        if (this.run !== run) return;
+        finish(run.rows.size === RUNTIMES.length ? null : 'The environment check stopped before finishing.');
+      }));
       run.timer = setTimeout(() => finish('The environment check timed out.'), this.timeoutMs);
       run.timer.unref();
     } catch { finish('Could not start the environment check.'); }

package/web/environment.js

@@ -20,7 +20,7 @@ export function createEnvironmentUI({ api, onAuthError, isAuthError = () => fals
     const note = host.querySelector('.environment-note');
     note.textContent = error ? 'Environment check unavailable'
       : data?.refreshing ? data.checkedAt ? 'Refreshing · showing previous check' : 'Checking environment…'
-        : data?.error ? 'Some checks could not finish'
+        : data?.error ? data.error
           : !data ? 'Not checked' : !found.length ? 'No runtime versions verified' : 'Manager environment';
   }