reset-framework-cli 1.1.2 → 1.1.5

package/src/lib/process.js

@@ -1,206 +1,303 @@
-import { spawn } from "node:child_process"
-
-import { logger } from "./logger.js"
-
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-export function resolveNpmCommand() {
-  return process.platform === "win32" ? "npm.cmd" : "npm"
-}
-
-export function resolvePackageManagerCommand(packageManager = "npm") {
-  if (packageManager === "npm") {
-    return resolveNpmCommand()
-  }
-
-  if (packageManager === "yarn") {
-    return process.platform === "win32" ? "yarn.cmd" : "yarn"
-  }
-
-  if (packageManager === "pnpm") {
-    return process.platform === "win32" ? "pnpm.cmd" : "pnpm"
-  }
-
-  if (packageManager === "bun") {
-    return process.platform === "win32" ? "bun.exe" : "bun"
-  }
-
-  throw new Error(`Unsupported package manager: ${packageManager}`)
-}
-
-export function getInstallCommandArgs(packageManager = "npm") {
-  if (packageManager === "npm") {
-    return ["install", "--include=optional"]
-  }
-
-  if (packageManager === "yarn") {
-    return ["install"]
-  }
-
-  return ["install"]
-}
-
+import { spawn, spawnSync } from "node:child_process"
+
+import { logger } from "./logger.js"
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+export function resolveNpmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm"
+}
+
+export function resolvePackageManagerCommand(packageManager = "npm") {
+  if (packageManager === "npm") {
+    return resolveNpmCommand()
+  }
+
+  if (packageManager === "yarn") {
+    return process.platform === "win32" ? "yarn.cmd" : "yarn"
+  }
+
+  if (packageManager === "pnpm") {
+    return process.platform === "win32" ? "pnpm.cmd" : "pnpm"
+  }
+
+  if (packageManager === "bun") {
+    return process.platform === "win32" ? "bun.exe" : "bun"
+  }
+
+  throw new Error(`Unsupported package manager: ${packageManager}`)
+}
+
+export function getInstallCommandArgs(packageManager = "npm") {
+  if (packageManager === "npm") {
+    return ["install", "--include=optional"]
+  }
+
+  if (packageManager === "yarn") {
+    return ["install"]
+  }
+
+  return ["install"]
+}
+
 export function formatCommand(command, args = []) {
   return [command, ...args].join(" ")
 }
 
+function shouldUseShell(command) {
+  return process.platform === "win32" && typeof command === "string" && /\.(cmd|bat)$/i.test(command)
+}
+
 export async function runCommand(command, args = [], options = {}) {
   const { cwd, dryRun = false, env } = options
 
   logger.info(`$ ${formatCommand(command, args)}`)
-
-  if (dryRun) {
-    return
-  }
-
+
+  if (dryRun) {
+    return
+  }
+
   await new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
       env: env ? { ...process.env, ...env } : process.env,
-      stdio: "inherit"
+      stdio: "inherit",
+      shell: shouldUseShell(command)
     })
 
     child.once("error", reject)
-    child.once("exit", (code, signal) => {
-      if (code === 0) {
-        resolve(undefined)
-        return
-      }
-
-      reject(
-        new Error(
-          signal
-            ? `Command terminated by signal: ${signal}`
-            : `Command exited with code ${code}`
-        )
-      )
-    })
-  })
-}
-
-export async function captureCommandOutput(command, args = [], options = {}) {
-  const { cwd, env } = options
-
-  await Promise.resolve()
-
+    child.once("exit", (code, signal) => {
+      if (code === 0) {
+        resolve(undefined)
+        return
+      }
+
+      reject(
+        new Error(
+          signal
+            ? `Command terminated by signal: ${signal}`
+            : `Command exited with code ${code}`
+        )
+      )
+    })
+  })
+}
+
+export async function captureCommandOutput(command, args = [], options = {}) {
+  const { cwd, env } = options
+
+  await Promise.resolve()
+
   return await new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       cwd,
       env: env ? { ...process.env, ...env } : process.env,
-      stdio: ["ignore", "pipe", "pipe"]
-    })
-
-    let stdout = ""
-    let stderr = ""
-
-    child.stdout?.on("data", (chunk) => {
-      stdout += String(chunk)
-    })
-
-    child.stderr?.on("data", (chunk) => {
-      stderr += String(chunk)
-    })
-
-    child.once("error", reject)
-    child.once("exit", (code, signal) => {
-      if (code === 0) {
-        resolve(stdout.trim())
-        return
-      }
-
-      reject(
-        new Error(
-          signal
-            ? `Command terminated by signal: ${signal}`
-            : (stderr.trim() || stdout.trim() || `Command exited with code ${code}`)
-        )
-      )
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: shouldUseShell(command)
     })
-  })
-}
-
+
+    let stdout = ""
+    let stderr = ""
+
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk)
+    })
+
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk)
+    })
+
+    child.once("error", reject)
+    child.once("exit", (code, signal) => {
+      if (code === 0) {
+        resolve(stdout.trim())
+        return
+      }
+
+      reject(
+        new Error(
+          signal
+            ? `Command terminated by signal: ${signal}`
+            : (stderr.trim() || stdout.trim() || `Command exited with code ${code}`)
+        )
+      )
+    })
+  })
+}
+
 export function spawnCommand(command, args = [], options = {}) {
   const { cwd, dryRun = false, env } = options
 
   logger.info(`$ ${formatCommand(command, args)}`)
-
-  if (dryRun) {
-    return null
-  }
-
+
+  if (dryRun) {
+    return null
+  }
+
   return spawn(command, args, {
     cwd,
     env: env ? { ...process.env, ...env } : process.env,
-    stdio: "inherit"
+    detached: process.platform !== "win32",
+    stdio: "inherit",
+    shell: shouldUseShell(command)
   })
 }
+
+export function waitForProcessExit(child, label) {
+  return new Promise((resolve, reject) => {
+    child.once("error", reject)
+    child.once("exit", (code, signal) => {
+      if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
+        resolve(undefined)
+        return
+      }
+
+      reject(
+        new Error(
+          signal
+            ? `${label} terminated by signal: ${signal}`
+            : `${label} exited with code ${code}`
+        )
+      )
+    })
+  })
+}
+
+export function registerChildCleanup(children) {
+  const activeChildren = children.filter(Boolean)
+  let cleanupPromise = null
 
-export function waitForProcessExit(child, label) {
-  return new Promise((resolve, reject) => {
-    child.once("error", reject)
-    child.once("exit", (code, signal) => {
-      if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
-        resolve(undefined)
+  const waitForChildExit = (child, timeoutMs = 3000) =>
+    new Promise((resolve) => {
+      if (!child || child.exitCode !== null || child.signalCode !== null) {
+        resolve(true)
         return
       }
 
-      reject(
-        new Error(
-          signal
-            ? `${label} terminated by signal: ${signal}`
-            : `${label} exited with code ${code}`
-        )
-      )
+      const handleExit = () => {
+        clearTimeout(timeout)
+        child.off("error", handleError)
+        resolve(true)
+      }
+
+      const handleError = () => {
+        clearTimeout(timeout)
+        child.off("exit", handleExit)
+        resolve(true)
+      }
+
+      const timeout = setTimeout(() => {
+        child.off("exit", handleExit)
+        child.off("error", handleError)
+        resolve(false)
+      }, timeoutMs)
+
+      child.once("exit", handleExit)
+      child.once("error", handleError)
     })
-  })
-}
 
-export function registerChildCleanup(children) {
-  const activeChildren = children.filter(Boolean)
+  const terminateChild = async (child) => {
+    if (!child || child.pid == null || child.exitCode !== null || child.signalCode !== null) {
+      return
+    }
+
+    if (process.platform === "win32") {
+      const result = spawnSync("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      })
+
+      if (result.status !== 0 && child.exitCode === null && child.signalCode === null) {
+        try {
+          child.kill("SIGTERM")
+        } catch {
+          // Ignore late shutdown races.
+        }
+      }
 
-  const cleanup = () => {
-    for (const child of activeChildren) {
-      if (child.exitCode === null && !child.killed) {
-        child.kill("SIGTERM")
+      await waitForChildExit(child, 2000)
+      return
+    }
+
+    try {
+      process.kill(-child.pid, "SIGTERM")
+    } catch (error) {
+      if (error?.code !== "ESRCH") {
+        try {
+          child.kill("SIGTERM")
+        } catch {
+          // Ignore late shutdown races.
+        }
       }
     }
+
+    if (await waitForChildExit(child, 3000)) {
+      return
+    }
+
+    try {
+      process.kill(-child.pid, "SIGKILL")
+    } catch (error) {
+      if (error?.code !== "ESRCH") {
+        try {
+          child.kill("SIGKILL")
+        } catch {
+          // Ignore late shutdown races.
+        }
+      }
+    }
+
+    await waitForChildExit(child, 1000)
+  }
+
+  const cleanup = async () => {
+    if (cleanupPromise) {
+      return cleanupPromise
+    }
+
+    cleanupPromise = (async () => {
+      await Promise.all(activeChildren.map((child) => terminateChild(child)))
+    })()
+
+    return cleanupPromise
   }
 
   const handleSignal = () => {
-    cleanup()
-    process.exit(0)
+    void cleanup().finally(() => {
+      process.exit(0)
+    })
   }
 
   process.on("SIGINT", handleSignal)
   process.on("SIGTERM", handleSignal)
 
-  return () => {
+  return async () => {
     process.off("SIGINT", handleSignal)
     process.off("SIGTERM", handleSignal)
-    cleanup()
+    await cleanup()
   }
 }
-
-export async function waitForUrl(url, options = {}) {
-  const { intervalMs = 250, timeoutMs = 15000 } = options
-  const deadline = Date.now() + timeoutMs
-
-  while (Date.now() < deadline) {
-    try {
-      const response = await fetch(url)
-      if (response.status < 500) {
-        return
-      }
-    } catch {
-      // Retry until timeout.
-    }
-
-    await sleep(intervalMs)
-  }
-
-  throw new Error(`Timed out waiting for ${url}`)
-}
+
+export async function waitForUrl(url, options = {}) {
+  const { intervalMs = 250, timeoutMs = 15000 } = options
+  const deadline = Date.now() + timeoutMs
+
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url)
+      if (response.status < 500) {
+        return
+      }
+    } catch {
+      // Retry until timeout.
+    }
+
+    await sleep(intervalMs)
+  }
+
+  throw new Error(`Timed out waiting for ${url}`)
+}