@serviceme/devtools-core 0.4.5 → 0.4.6

package/dist/index.d.mts

@@ -266,9 +266,17 @@ declare class EnvironmentInspector {
     private readonly runCommandFn;
     private readonly platform;
     private readonly shell;
+    /**
+     * 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).
+     */
+    private readonly toolCheckCache;
     constructor(options?: EnvironmentInspectorOptions);
     checkEnvironment(): Promise<EnvironmentCheckResult>;
     checkTool(toolName: KnownEnvironmentTool): Promise<ToolCheckResult>;
+    private performToolCheck;
     private getToolPath;
     private getToolPathFromLoginShell;
     /**
@@ -281,6 +289,12 @@ declare class EnvironmentInspector {
     private getToolVersion;
     private shouldUsePosixLoginShellFallback;
     private checkNvm;
+    /**
+     * 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.
+     */
+    private resolveNvmShPath;
     private checkNuget;
     private getVersionInvocation;
     private getToolTimeout;

package/dist/index.d.ts

@@ -266,9 +266,17 @@ declare class EnvironmentInspector {
     private readonly runCommandFn;
     private readonly platform;
     private readonly shell;
+    /**
+     * 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).
+     */
+    private readonly toolCheckCache;
     constructor(options?: EnvironmentInspectorOptions);
     checkEnvironment(): Promise<EnvironmentCheckResult>;
     checkTool(toolName: KnownEnvironmentTool): Promise<ToolCheckResult>;
+    private performToolCheck;
     private getToolPath;
     private getToolPathFromLoginShell;
     /**
@@ -281,6 +289,12 @@ declare class EnvironmentInspector {
     private getToolVersion;
     private shouldUsePosixLoginShellFallback;
     private checkNvm;
+    /**
+     * 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.
+     */
+    private resolveNvmShPath;
     private checkNuget;
     private getVersionInvocation;
     private getToolTimeout;

package/dist/index.js

@@ -1519,7 +1519,8 @@ var import_devtools_protocol2 = require("@serviceme/devtools-protocol");
 
 // src/process/runCommand.ts
 var import_node_child_process = require("child_process");
-function terminateCommandProcess(child) {
+var FORCE_KILL_DELAY_MS = 2e3;
+function terminateCommandProcess(child, signal = "SIGTERM") {
   if (child.killed) {
     return;
   }
@@ -1533,7 +1534,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) => {
@@ -1542,12 +1568,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;
@@ -1556,6 +1586,9 @@ async function runCommand(command, options = {}) {
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
+      if (forceKillTimer) {
+        clearTimeout(forceKillTimer);
+      }
       handler();
     };
     child.stdout?.setEncoding("utf8");
@@ -1570,6 +1603,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({
@@ -1605,6 +1642,7 @@ async function runCommand(command, options = {}) {
           error.stderr = stderr;
           reject(error);
         });
+        forceKillTimer = scheduleForceKill(child);
       }, options.timeoutMs);
     }
   });
@@ -2715,6 +2753,9 @@ async function collectRecursive(absDir, root, out) {
 }
 
 // src/env/environmentInspector.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
 var import_devtools_protocol4 = require("@serviceme/devtools-protocol");
 var DEFAULT_TOOL_CHECK_TIMEOUT_MS = 5e3;
 var TOOL_CHECK_TIMEOUT_MS = {
@@ -2762,11 +2803,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(
       import_devtools_protocol4.KNOWN_ENVIRONMENT_TOOLS.map(async (tool) => [tool, await this.checkTool(tool)])
     );
@@ -2776,6 +2825,15 @@ var EnvironmentInspector = class {
     if (!/^[a-zA-Z0-9-]+$/.test(toolName)) {
       throw (0, import_devtools_protocol4.createServicemeError)("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();
@@ -2887,6 +2945,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,
@@ -2904,6 +2968,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/, (0, import_node_os.homedir)()));
+    }
+    for (const candidate of candidates) {
+      const scriptPath = (0, import_node_path.join)(candidate, "nvm.sh");
+      if ((0, import_node_fs.existsSync)(scriptPath)) {
+        return scriptPath;
+      }
+    }
+    return void 0;
+  }
   async checkNuget() {
     const dotnetPath = await this.getToolPath("dotnet");
     if (!dotnetPath) {
@@ -3611,9 +3697,9 @@ var path11 = __toESM(require("path"));
 var import_devtools_protocol7 = require("@serviceme/devtools-protocol");
 
 // src/utils/fileUtils.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_promises3 = require("fs/promises");
-var import_node_path = require("path");
+var import_node_path2 = require("path");
 var import_yauzl = __toESM(require("yauzl"));
 var unzipFile = (zipPath, dest) => {
   return new Promise((resolve3, reject) => {
@@ -3623,18 +3709,18 @@ var unzipFile = (zipPath, dest) => {
       zipfile.readEntry();
       zipfile.on("entry", (entry) => {
         if (/\/$/.test(entry.fileName)) {
-          void (0, import_promises3.mkdir)((0, import_node_path.join)(dest, entry.fileName), { recursive: true }).then(() => {
+          void (0, import_promises3.mkdir)((0, import_node_path2.join)(dest, entry.fileName), { recursive: true }).then(() => {
             zipfile.readEntry();
           }).catch(reject);
         } else {
-          const outputPath = (0, import_node_path.join)(dest, entry.fileName);
-          void (0, import_promises3.mkdir)((0, import_node_path.dirname)(outputPath), { recursive: true }).then(() => {
+          const outputPath = (0, import_node_path2.join)(dest, entry.fileName);
+          void (0, import_promises3.mkdir)((0, import_node_path2.dirname)(outputPath), { recursive: true }).then(() => {
             zipfile.openReadStream(
               entry,
               (streamError, readStream) => {
                 if (streamError) return reject(streamError);
                 if (!readStream) return reject(new Error("Failed to open zip entry stream."));
-                const writeStream = (0, import_node_fs.createWriteStream)(outputPath);
+                const writeStream = (0, import_node_fs2.createWriteStream)(outputPath);
                 readStream.on("error", reject);
                 writeStream.on("error", reject);
                 writeStream.on("close", () => {
@@ -3676,7 +3762,7 @@ var mergeEntry = async (sourcePath, destPath, overwrite) => {
     await (0, import_promises3.mkdir)(destPath, { recursive: true });
     const children = await (0, import_promises3.readdir)(sourcePath);
     for (const child of children) {
-      await mergeEntry((0, import_node_path.join)(sourcePath, child), (0, import_node_path.join)(destPath, child), overwrite);
+      await mergeEntry((0, import_node_path2.join)(sourcePath, child), (0, import_node_path2.join)(destPath, child), overwrite);
     }
     await (0, import_promises3.rm)(sourcePath, { recursive: true, force: true });
     return;
@@ -3699,11 +3785,11 @@ var moveFiles = async (sourceDir, destDir, overwrite = false) => {
   await (0, import_promises3.mkdir)(destDir, { recursive: true });
   const files = await (0, import_promises3.readdir)(sourceDir);
   for (const file of files) {
-    const sourceFile = (0, import_node_path.join)(sourceDir, file);
-    const destFile = (0, import_node_path.join)(destDir, file);
+    const sourceFile = (0, import_node_path2.join)(sourceDir, file);
+    const destFile = (0, import_node_path2.join)(destDir, file);
     if (!overwrite) {
       try {
-        await (0, import_promises3.access)(destFile, import_node_fs.constants.F_OK);
+        await (0, import_promises3.access)(destFile, import_node_fs2.constants.F_OK);
         await (0, import_promises3.rm)(sourceFile, { recursive: true, force: true });
         continue;
       } catch {