@serviceme/devtools-core 0.4.5 → 0.4.6

package/dist/index.mjs

@@ -1325,7 +1325,8 @@ import {
 
 // src/process/runCommand.ts
 import { spawn } from "child_process";
-function terminateCommandProcess(child) {
+var FORCE_KILL_DELAY_MS = 2e3;
+function terminateCommandProcess(child, signal = "SIGTERM") {
   if (child.killed) {
     return;
   }
@@ -1339,7 +1340,32 @@ function terminateCommandProcess(child) {
     });
     return;
   }
-  child.kill("SIGTERM");
+  const pid = child.pid;
+  if (pid) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+    }
+  }
+  child.kill(signal);
+}
+function scheduleForceKill(child) {
+  if (process.platform === "win32") {
+    return void 0;
+  }
+  const pid = child.pid;
+  if (pid === void 0) {
+    return void 0;
+  }
+  const timer = setTimeout(() => {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+    }
+  }, FORCE_KILL_DELAY_MS);
+  timer.unref?.();
+  return timer;
 }
 async function runCommand(command, options = {}) {
   return new Promise((resolve3, reject) => {
@@ -1348,12 +1374,16 @@ async function runCommand(command, options = {}) {
       env: options.env,
       shell: options.shell,
       stdio: "pipe",
-      windowsHide: true
+      windowsHide: true,
+      // POSIX: run the command in its own process group so a timeout can
+      // terminate the whole tree (login shell + its children) at once.
+      detached: process.platform !== "win32"
     });
     let stdout = "";
     let stderr = "";
     let finished = false;
     let timeoutId;
+    let forceKillTimer;
     const finish = (handler) => {
       if (finished) {
         return;
@@ -1362,6 +1392,9 @@ async function runCommand(command, options = {}) {
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
+      if (forceKillTimer) {
+        clearTimeout(forceKillTimer);
+      }
       handler();
     };
     child.stdout?.setEncoding("utf8");
@@ -1376,6 +1409,10 @@ async function runCommand(command, options = {}) {
       finish(() => reject(error));
     });
     child.once("close", (code) => {
+      if (forceKillTimer) {
+        clearTimeout(forceKillTimer);
+        forceKillTimer = void 0;
+      }
       finish(() => {
         if (code === 0) {
           resolve3({
@@ -1411,6 +1448,7 @@ async function runCommand(command, options = {}) {
           error.stderr = stderr;
           reject(error);
         });
+        forceKillTimer = scheduleForceKill(child);
       }, options.timeoutMs);
     }
   });
@@ -2525,6 +2563,9 @@ async function collectRecursive(absDir, root, out) {
 }
 
 // src/env/environmentInspector.ts
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join7 } from "path";
 import {
   createServicemeError as createServicemeError4,
   KNOWN_ENVIRONMENT_TOOLS
@@ -2575,11 +2616,19 @@ function posixLoginShellArgs(platform3, envShell, command) {
 }
 var EnvironmentInspector = class {
   constructor(options = {}) {
+    /**
+     * Per-check-cycle result cache. `checkEnvironment()` clears it before
+     * probing so a fresh cycle never returns stale results, while concurrent
+     * or repeated `checkTool()` calls within the same cycle share one probe
+     * (deduplicating expensive login-shell fallbacks).
+     */
+    this.toolCheckCache = /* @__PURE__ */ new Map();
     this.runCommandFn = options.runCommand ?? runCommand;
     this.platform = options.platform ?? process.platform;
     this.shell = options.shell ?? process.env.SHELL;
   }
   async checkEnvironment() {
+    this.toolCheckCache.clear();
     const results = await Promise.all(
       KNOWN_ENVIRONMENT_TOOLS.map(async (tool) => [tool, await this.checkTool(tool)])
     );
@@ -2589,6 +2638,15 @@ var EnvironmentInspector = class {
     if (!/^[a-zA-Z0-9-]+$/.test(toolName)) {
       throw createServicemeError4("invalid_params", "Invalid tool name.");
     }
+    const cached = this.toolCheckCache.get(toolName);
+    if (cached) {
+      return cached;
+    }
+    const check = this.performToolCheck(toolName);
+    this.toolCheckCache.set(toolName, check);
+    return check;
+  }
+  async performToolCheck(toolName) {
     try {
       if (toolName === "nvm") {
         return await this.checkNvm();
@@ -2700,6 +2758,12 @@ var EnvironmentInspector = class {
       }
     }
     try {
+      if (!this.resolveNvmShPath()) {
+        return {
+          installed: false,
+          error: "Not installed"
+        };
+      }
       const nvmArgs = posixLoginShellArgs(this.platform, this.shell, "nvm --version");
       const result = await this.runCommandFn(nvmArgs.command, {
         args: nvmArgs.args,
@@ -2717,6 +2781,28 @@ var EnvironmentInspector = class {
       };
     }
   }
+  /**
+   * Resolve `nvm.sh` from `$NVM_DIR` and the known install roots without
+   * spawning a shell. Returns undefined when nvm is not installed in any
+   * well-known location, letting callers skip a login-shell probe.
+   */
+  resolveNvmShPath() {
+    const candidates = [];
+    const nvmDir = process.env.NVM_DIR?.trim();
+    if (nvmDir && nvmDir.length > 0) {
+      candidates.push(nvmDir);
+    }
+    for (const dir of NVM_FALLBACK_DIRS) {
+      candidates.push(dir.replace(/^\$HOME/, homedir2()));
+    }
+    for (const candidate of candidates) {
+      const scriptPath = join7(candidate, "nvm.sh");
+      if (existsSync(scriptPath)) {
+        return scriptPath;
+      }
+    }
+    return void 0;
+  }
   async checkNuget() {
     const dotnetPath = await this.getToolPath("dotnet");
     if (!dotnetPath) {
@@ -3433,7 +3519,7 @@ import {
 // src/utils/fileUtils.ts
 import { constants, createWriteStream } from "fs";
 import { access as access5, copyFile, lstat, mkdir as mkdir5, readdir as readdir3, rename as rename4, rm as rm3 } from "fs/promises";
-import { dirname as dirname7, join as join8 } from "path";
+import { dirname as dirname7, join as join9 } from "path";
 import yauzl from "yauzl";
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve3, reject) => {
@@ -3443,11 +3529,11 @@ var unzipFile = (zipPath, dest) => {
       zipfile.readEntry();
       zipfile.on("entry", (entry) => {
         if (/\/$/.test(entry.fileName)) {
-          void mkdir5(join8(dest, entry.fileName), { recursive: true }).then(() => {
+          void mkdir5(join9(dest, entry.fileName), { recursive: true }).then(() => {
             zipfile.readEntry();
           }).catch(reject);
         } else {
-          const outputPath = join8(dest, entry.fileName);
+          const outputPath = join9(dest, entry.fileName);
           void mkdir5(dirname7(outputPath), { recursive: true }).then(() => {
             zipfile.openReadStream(
               entry,
@@ -3496,7 +3582,7 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await mkdir5(destPath, { recursive: true });
     const children = await readdir3(sourcePath);
     for (const child of children) {
-      await mergeEntry(join8(sourcePath, child), join8(destPath, child), overwrite);
+      await mergeEntry(join9(sourcePath, child), join9(destPath, child), overwrite);
     }
     await rm3(sourcePath, { recursive: true, force: true });
     return;
@@ -3519,8 +3605,8 @@ var moveFiles = async (sourceDir, destDir, overwrite = false) => {
   await mkdir5(destDir, { recursive: true });
   const files = await readdir3(sourceDir);
   for (const file of files) {
-    const sourceFile = join8(sourceDir, file);
-    const destFile = join8(destDir, file);
+    const sourceFile = join9(sourceDir, file);
+    const destFile = join9(destDir, file);
     if (!overwrite) {
       try {
         await access5(destFile, constants.F_OK);