tryharness 0.7.23 → 0.7.25

package/lib/agentnode.mjs

@@ -13,21 +13,48 @@ const WINDOWS = process.platform === "win32";
 /** The executable a command name runs on this PATH. */
 export function onPath(command, envPath = process.env.PATH || "") {
   for (const dir of String(envPath).split(path.delimiter).filter(Boolean)) {
-    for (const name of WINDOWS ? [`${command}.exe`, `${command}.cmd`, command] : [command]) {
+    for (const name of WINDOWS
+      ? [`${command}.exe`, `${command}.cmd`, command]
+      : [command]) {
       const file = path.join(dir, name);
-      try { if (fs.statSync(file).isFile()) { fs.accessSync(file, fs.constants.X_OK); return file; } } catch {}
+      try {
+        if (fs.statSync(file).isFile()) {
+          fs.accessSync(file, fs.constants.X_OK);
+          return file;
+        }
+      } catch {}
     }
   }
   return null;
 }
 
-const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; } };
-const real = (file) => { try { return fs.realpathSync(file); } catch { return file; } };
+const readJson = (file) => {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+};
+const real = (file) => {
+  try {
+    return fs.realpathSync(file);
+  } catch {
+    return file;
+  }
+};
 
 /** Whether a file is a script Node runs (`#!/usr/bin/env node`), not a native program. */
 function nodeScript(file) {
   let head = "";
-  try { const fd = fs.openSync(file, "r"); const buffer = Buffer.alloc(200); fs.readSync(fd, buffer, 0, 200, 0); fs.closeSync(fd); head = buffer.toString("utf8"); } catch { return false; }
+  try {
+    const fd = fs.openSync(file, "r");
+    const buffer = Buffer.alloc(200);
+    fs.readSync(fd, buffer, 0, 200, 0);
+    fs.closeSync(fd);
+    head = buffer.toString("utf8");
+  } catch {
+    return false;
+  }
   return head.startsWith("#!") && /\bnode\b/.test(head.split("\n")[0]);
 }
 
@@ -35,9 +62,23 @@ function nodeScript(file) {
 function managedEntry(launcher, command) {
   const dir = path.dirname(path.dirname(launcher));
   let version = "";
-  try { version = fs.readFileSync(path.join(dir, "install", "current-version"), "utf8").trim(); } catch { return null; }
+  try {
+    version = fs
+      .readFileSync(path.join(dir, "install", "current-version"), "utf8")
+      .trim();
+  } catch {
+    return null;
+  }
   if (!/^[\w.+-]+$/.test(version)) return null;
-  const entry = path.join(dir, "install", "releases", version, "node_modules", ".bin", command);
+  const entry = path.join(
+    dir,
+    "install",
+    "releases",
+    version,
+    "node_modules",
+    ".bin",
+    command
+  );
   return fs.existsSync(entry) ? real(entry) : null;
 }
 
@@ -49,33 +90,66 @@ export function nodeRange(command, envPath = process.env.PATH || "") {
   if (!nodeScript(entry)) return null;
   for (let dir = path.dirname(entry); ; dir = path.dirname(dir)) {
     const pkg = readJson(path.join(dir, "package.json"));
-    if (pkg?.name) return typeof pkg.engines?.node === "string" && pkg.engines.node.trim() ? pkg.engines.node.trim() : null;
+    if (pkg?.name)
+      return typeof pkg.engines?.node === "string" && pkg.engines.node.trim()
+        ? pkg.engines.node.trim()
+        : null;
     if (path.dirname(dir) === dir) return null;
   }
 }
 
 // ── Versions and ranges (the forms package.json engines use) ─────────────────
 
-const parse = (text) => { const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(String(text).trim()); return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null; };
+const parse = (text) => {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(String(text).trim());
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+};
 const compare = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
 
 /** One comparator (">=22.19.0", "^20", "~18.2", "22.x", "<23"); one it does not understand holds nothing back. */
 function holds(version, comparator) {
   if (["", "*", "x", "X"].includes(comparator)) return true;
-  const m = /^(>=|<=|>|<|=|\^|~)?v?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?$/.exec(comparator);
+  const m =
+    /^(>=|<=|>|<|=|\^|~)?v?(\d+)(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?$/.exec(
+      comparator
+    );
   if (!m) return true;
   const [, op = "", major, minor, patch] = m;
-  const part = (value) => (value === undefined || /^[xX*]$/.test(value) ? null : Number(value));
+  const part = (value) =>
+    value === undefined || /^[xX*]$/.test(value) ? null : Number(value);
   const low = [Number(major), part(minor) ?? 0, part(patch) ?? 0];
   // The first version past a partial one: "22" ends before 23.0.0, "22.4" before 22.5.0.
-  const past = part(minor) === null ? [low[0] + 1, 0, 0] : part(patch) === null ? [low[0], low[1] + 1, 0] : [low[0], low[1], low[2] + 1];
+  const past =
+    part(minor) === null
+      ? [low[0] + 1, 0, 0]
+      : part(patch) === null
+        ? [low[0], low[1] + 1, 0]
+        : [low[0], low[1], low[2] + 1];
   const at = compare(version, low);
   if (op === ">=") return at >= 0;
   if (op === ">") return compare(version, past) >= 0;
   if (op === "<") return at < 0;
   if (op === "<=") return compare(version, past) < 0;
-  if (op === "^") return at >= 0 && compare(version, low[0] > 0 ? [low[0] + 1, 0, 0] : low[1] > 0 ? [0, low[1] + 1, 0] : [0, 0, low[2] + 1]) < 0;
-  if (op === "~") return at >= 0 && compare(version, part(minor) === null ? [low[0] + 1, 0, 0] : [low[0], low[1] + 1, 0]) < 0;
+  if (op === "^")
+    return (
+      at >= 0 &&
+      compare(
+        version,
+        low[0] > 0
+          ? [low[0] + 1, 0, 0]
+          : low[1] > 0
+            ? [0, low[1] + 1, 0]
+            : [0, 0, low[2] + 1]
+      ) < 0
+    );
+  if (op === "~")
+    return (
+      at >= 0 &&
+      compare(
+        version,
+        part(minor) === null ? [low[0] + 1, 0, 0] : [low[0], low[1] + 1, 0]
+      ) < 0
+    );
   return at >= 0 && compare(version, past) < 0;
 }
 
@@ -83,11 +157,15 @@ function holds(version, comparator) {
 export function satisfies(version, range) {
   const parsed = parse(version);
   if (!parsed) return false;
-  return String(range).split("||").some((alternative) => {
-    const hyphen = /^\s*(\S+)\s+-\s+(\S+)\s*$/.exec(alternative);
-    const comparators = hyphen ? [`>=${hyphen[1]}`, `<=${hyphen[2]}`] : alternative.trim().split(/\s+/).filter(Boolean);
-    return comparators.every((comparator) => holds(parsed, comparator));
-  });
+  return String(range)
+    .split("||")
+    .some((alternative) => {
+      const hyphen = /^\s*(\S+)\s+-\s+(\S+)\s*$/.exec(alternative);
+      const comparators = hyphen
+        ? [`>=${hyphen[1]}`, `<=${hyphen[2]}`]
+        : alternative.trim().split(/\s+/).filter(Boolean);
+      return comparators.every((comparator) => holds(parsed, comparator));
+    });
 }
 
 // ── The Nodes on this computer ───────────────────────────────────────────────
@@ -97,7 +175,10 @@ const versions = new Map();
 function versionOf(node) {
   if (!versions.has(node)) {
     const said = spawnSync(node, ["-v"], { encoding: "utf8", timeout: 5_000 });
-    versions.set(node, said.status === 0 && parse(said.stdout) ? said.stdout.trim() : null);
+    versions.set(
+      node,
+      said.status === 0 && parse(said.stdout) ? said.stdout.trim() : null
+    );
   }
   return versions.get(node);
 }
@@ -105,13 +186,33 @@ function versionOf(node) {
 /** Every Node installed where people put them: version managers, Homebrew, the system's, the one Harness runs on. */
 export function installedNodes(envPath = process.env.PATH || "") {
   const home = os.homedir();
-  const bin = (dir) => (WINDOWS ? [path.join(dir, "node.exe")] : [path.join(dir, "bin", "node"), path.join(dir, "installation", "bin", "node")]);
+  const bin = (dir) =>
+    WINDOWS
+      ? [path.join(dir, "node.exe")]
+      : [
+          path.join(dir, "bin", "node"),
+          path.join(dir, "installation", "bin", "node"),
+        ];
   const managers = [
-    process.env.NVM_DIR ? path.join(process.env.NVM_DIR, "versions", "node") : path.join(home, ".nvm", "versions", "node"),
-    path.join(process.env.FNM_DIR || path.join(home, ".local", "share", "fnm"), "node-versions"),
+    process.env.NVM_DIR
+      ? path.join(process.env.NVM_DIR, "versions", "node")
+      : path.join(home, ".nvm", "versions", "node"),
+    path.join(
+      process.env.FNM_DIR || path.join(home, ".local", "share", "fnm"),
+      "node-versions"
+    ),
     path.join(home, "Library", "Application Support", "fnm", "node-versions"),
-    path.join(process.env.VOLTA_HOME || path.join(home, ".volta"), "tools", "image", "node"),
-    path.join(process.env.ASDF_DATA_DIR || path.join(home, ".asdf"), "installs", "nodejs"),
+    path.join(
+      process.env.VOLTA_HOME || path.join(home, ".volta"),
+      "tools",
+      "image",
+      "node"
+    ),
+    path.join(
+      process.env.ASDF_DATA_DIR || path.join(home, ".asdf"),
+      "installs",
+      "nodejs"
+    ),
     path.join(home, ".local", "share", "mise", "installs", "node"),
     path.join(process.env.N_PREFIX || "/usr/local", "n", "versions", "node"),
     ...(process.env.NVM_HOME ? [process.env.NVM_HOME] : []),
@@ -120,18 +221,45 @@ export function installedNodes(envPath = process.env.PATH || "") {
   const found = [process.execPath, onPath("node", envPath)];
   for (const dir of managers) {
     let entries = [];
-    try { entries = fs.readdirSync(dir); } catch { continue; }
+    try {
+      entries = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
     for (const entry of entries) found.push(...bin(path.join(dir, entry)));
   }
   for (const brew of ["/opt/homebrew/opt", "/usr/local/opt"]) {
     let entries = [];
-    try { entries = fs.readdirSync(brew).filter((name) => /^node(@\d+)?$/.test(name)); } catch {}
-    for (const entry of entries) found.push(path.join(brew, entry, "bin", "node"));
+    try {
+      entries = fs
+        .readdirSync(brew)
+        .filter((name) => /^node(@\d+)?$/.test(name));
+    } catch {}
+    for (const entry of entries)
+      found.push(path.join(brew, entry, "bin", "node"));
   }
-  found.push(...(WINDOWS ? [path.join(process.env.ProgramFiles || "C:\\Program Files", "nodejs", "node.exe")] : ["/opt/homebrew/bin/node", "/usr/local/bin/node", "/usr/bin/node"]));
+  found.push(
+    ...(WINDOWS
+      ? [
+          path.join(
+            process.env.ProgramFiles || "C:\\Program Files",
+            "nodejs",
+            "node.exe"
+          ),
+        ]
+      : ["/opt/homebrew/bin/node", "/usr/local/bin/node", "/usr/bin/node"])
+  );
   const seen = new Set();
-  return found.filter((node) => node && fs.existsSync(node) && !seen.has(real(node)) && seen.add(real(node)))
-    .map((node) => ({ node, version: versionOf(node) })).filter((entry) => entry.version);
+  return found
+    .filter(
+      (node) =>
+        node &&
+        fs.existsSync(node) &&
+        !seen.has(real(node)) &&
+        seen.add(real(node))
+    )
+    .map((node) => ({ node, version: versionOf(node) }))
+    .filter((entry) => entry.version);
 }
 
 /**
@@ -144,11 +272,23 @@ export function agentEnvironment(command, env = process.env) {
   if (!range) return { env };
   const current = onPath("node", env.PATH);
   const have = current ? versionOf(current) : null;
-  if (have && satisfies(have, range)) return { env, bin: path.dirname(current) };
-  const fits = installedNodes(env.PATH).filter((entry) => satisfies(entry.version, range))
+  if (have && satisfies(have, range))
+    return { env, bin: path.dirname(current) };
+  const fits = installedNodes(env.PATH)
+    .filter((entry) => satisfies(entry.version, range))
     .sort((a, b) => compare(parse(b.version), parse(a.version)))[0];
   if (!fits) {
-    return { env, error: `${command} needs Node ${range}, and this computer has ${have ? `Node ${have.replace(/^v/, "")}` : "no Node"} and no other in that range. Install one (for example: nvm install 22), then ask again.` };
+    return {
+      env,
+      error: `${command} needs Node ${range}, and this computer has ${have ? `Node ${have.replace(/^v/, "")}` : "no Node"} and no other in that range. Install one (for example: nvm install 22), then ask again.`,
+    };
   }
-  return { env: { ...env, PATH: [path.dirname(fits.node), env.PATH || ""].join(path.delimiter) }, bin: path.dirname(fits.node), node: fits.version };
+  return {
+    env: {
+      ...env,
+      PATH: [path.dirname(fits.node), env.PATH || ""].join(path.delimiter),
+    },
+    bin: path.dirname(fits.node),
+    node: fits.version,
+  };
 }