reset-framework-cli 1.1.4 → 1.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reset-framework-cli",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "type": "module",
   "description": "Command-line tooling for Reset Framework.",
   "license": "MIT",
@@ -11,9 +11,9 @@
     "node": ">=20.19.0"
   },
   "dependencies": {
-    "@reset-framework/native": "1.1.4",
-    "@reset-framework/schema": "1.1.4",
-    "@reset-framework/sdk": "1.1.4"
+    "@reset-framework/native": "1.1.5",
+    "@reset-framework/schema": "1.1.5",
+    "@reset-framework/sdk": "1.1.5"
   },
   "bin": {
     "reset-framework-cli": "src/index.js"

package/src/commands/dev.js

@@ -155,13 +155,13 @@ export async function run(context) {
 
   const cleanup = registerChildCleanup(children)
 
-  try {
-    await Promise.race([
-      ...children.map((child, index) =>
-        waitForProcessExit(child, index === 0 ? "dev process" : "native host")
-      )
-    ])
-  } finally {
-    cleanup()
-  }
-}
+  try {
+    await Promise.race([
+      ...children.map((child, index) =>
+        waitForProcessExit(child, index === 0 ? "dev process" : "native host")
+      )
+    ])
+  } finally {
+    await cleanup()
+  }
+}

package/src/commands/init.js

@@ -176,90 +176,7 @@ function App() {
 export default App
 `
 
-const rootFrontendRunner = `import { readFileSync } from 'node:fs'
-import path from 'node:path'
-import { spawn } from 'node:child_process'
-
-const script = process.argv[2]
-if (!script) {
-  throw new Error('Missing frontend script name.')
-}
-
-const appRoot = process.cwd()
-const config = JSON.parse(readFileSync(path.join(appRoot, 'reset.config.json'), 'utf8'))
-const frontendDir =
-  typeof config?.project?.frontendDir === 'string' && config.project.frontendDir.trim() !== ''
-    ? path.resolve(appRoot, config.project.frontendDir)
-    : path.join(appRoot, 'frontend')
-
-function shouldUseShell(command) {
-  return process.platform === 'win32' && typeof command === 'string' && /\\.(cmd|bat)$/i.test(command)
-}
-
-function resolvePackageManagerCommand() {
-  const packageJsonPath = path.join(appRoot, 'package.json')
-  const manifest = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
-  const packageManager = typeof manifest.packageManager === 'string' ? manifest.packageManager.trim() : ''
-  const name = packageManager.split('@')[0]
-
-  if (name === 'bun') {
-    return process.platform === 'win32' ? 'bun.exe' : 'bun'
-  }
-
-  if (name === 'pnpm') {
-    return process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm'
-  }
-
-  if (name === 'yarn') {
-    return process.platform === 'win32' ? 'yarn.cmd' : 'yarn'
-  }
-
-  if (name === 'npm') {
-    return process.platform === 'win32' ? 'npm.cmd' : 'npm'
-  }
-
-  const candidates = [
-    ['bun.lock', process.platform === 'win32' ? 'bun.exe' : 'bun'],
-    ['bun.lockb', process.platform === 'win32' ? 'bun.exe' : 'bun'],
-    ['pnpm-lock.yaml', process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm'],
-    ['yarn.lock', process.platform === 'win32' ? 'yarn.cmd' : 'yarn'],
-    ['package-lock.json', process.platform === 'win32' ? 'npm.cmd' : 'npm']
-  ]
-
-  for (const [fileName, command] of candidates) {
-    try {
-      readFileSync(path.join(appRoot, fileName), 'utf8')
-      return command
-    } catch {}
-  }
-
-  return process.platform === 'win32' ? 'npm.cmd' : 'npm'
-}
-
-const command = resolvePackageManagerCommand()
-const child = spawn(command, ['run', script, '--', ...process.argv.slice(3)], {
-  cwd: frontendDir,
-  stdio: 'inherit',
-  env: process.env,
-  shell: shouldUseShell(command)
-})
-
-child.once('error', (error) => {
-  console.error(error)
-  process.exit(1)
-})
-
-child.once('exit', (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal)
-    return
-  }
-
-  process.exit(code ?? 1)
-})
-`
-
-export const description = "Scaffold a starter app with an interactive project setup"
+export const description = "Scaffold a starter app with an interactive project setup"
 
 function listTemplates(templatesDir) {
   return readdirSync(templatesDir, { withFileTypes: true })
@@ -383,9 +300,31 @@ function resolvePackageManagerOption(context) {
   return "npm"
 }
 
-function describeInstallCommand(packageManager) {
-  return [packageManager, ...getInstallCommandArgs(packageManager)].join(" ")
-}
+function describeInstallCommand(packageManager) {
+  return [packageManager, ...getInstallCommandArgs(packageManager)].join(" ")
+}
+
+function createFrontendScriptCommand(packageManager, frontendDir, scriptName) {
+  const frontendPath = JSON.stringify(frontendDir.replace(/\\/g, "/"))
+
+  if (packageManager === "npm") {
+    return `npm --workspace ${frontendPath} run ${scriptName} --`
+  }
+
+  if (packageManager === "pnpm") {
+    return `pnpm --dir ${frontendPath} run ${scriptName} --`
+  }
+
+  if (packageManager === "yarn") {
+    return `yarn --cwd ${frontendPath} run ${scriptName}`
+  }
+
+  if (packageManager === "bun") {
+    return `bun --cwd ${frontendPath} run ${scriptName}`
+  }
+
+  throw new Error(`Unsupported package manager: ${packageManager}`)
+}
 
 async function ensureWritableTarget(targetDir, force) {
   if (!existsSync(targetDir)) {
@@ -491,13 +430,13 @@ function createRootPackageJson(options) {
     base.packageManager = packageManagerVersion
   }
 
-  if (options.frontendDir !== ".") {
-    base.workspaces = [options.frontendDir]
-    base.scripts["dev:web"] = "node ./scripts/run-frontend.mjs dev"
-    base.scripts["build:web"] = "node ./scripts/run-frontend.mjs build"
-    base.scripts["lint:web"] = "node ./scripts/run-frontend.mjs lint"
-    base.scripts["preview:web"] = "node ./scripts/run-frontend.mjs preview"
-  }
+  if (options.frontendDir !== ".") {
+    base.workspaces = [options.frontendDir]
+    base.scripts["dev:web"] = createFrontendScriptCommand(options.packageManager, options.frontendDir, "dev")
+    base.scripts["build:web"] = createFrontendScriptCommand(options.packageManager, options.frontendDir, "build")
+    base.scripts["lint:web"] = createFrontendScriptCommand(options.packageManager, options.frontendDir, "lint")
+    base.scripts["preview:web"] = createFrontendScriptCommand(options.packageManager, options.frontendDir, "preview")
+  }
 
   return base
 }
@@ -538,18 +477,14 @@ async function writeRootPackageFiles(options) {
     "utf8"
   )
 
-  if (options.frontendDir !== ".") {
-    await writeFile(
-      path.join(options.targetDir, "package.json"),
-      JSON.stringify(createRootPackageJson(options), null, 2) + "\n",
-      "utf8"
-    )
-
-    const scriptsDir = path.join(options.targetDir, "scripts")
-    await mkdir(scriptsDir, { recursive: true })
-    await writeFile(path.join(scriptsDir, "run-frontend.mjs"), rootFrontendRunner, "utf8")
-  }
-}
+  if (options.frontendDir !== ".") {
+    await writeFile(
+      path.join(options.targetDir, "package.json"),
+      JSON.stringify(createRootPackageJson(options), null, 2) + "\n",
+      "utf8"
+    )
+  }
+}
 
 async function writeProjectFiles(options) {
   const templateConfig = JSON.parse(await readFile(options.templateConfigPath, "utf8"))
@@ -846,14 +781,9 @@ export async function run(context) {
       ["plan", "Write Vite config", path.join(targetFrontendDir, "vite.config.ts")],
       ["plan", "Write TS config", path.join(targetFrontendDir, "tsconfig.app.json")]
     ])
-    if (options.frontendDir !== ".") {
-      printStatusTable([
-        ["plan", "Write frontend runner", path.join(options.targetDir, "scripts", "run-frontend.mjs")]
-      ])
-    }
-    if (options.styling === "tailwindcss") {
-      printStatusTable([
-        ["plan", "Patch package.json", path.join(targetFrontendDir, "package.json")],
+    if (options.styling === "tailwindcss") {
+      printStatusTable([
+        ["plan", "Patch package.json", path.join(targetFrontendDir, "package.json")],
         ["plan", "Write styles", path.join(targetFrontendDir, "src", "index.css")],
         ["plan", "Write starter screen", path.join(targetFrontendDir, "src", "App.tsx")]
       ])

package/src/lib/process.js

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process"
+import { spawn, spawnSync } from "node:child_process"
 
 import { logger } from "./logger.js"
 
@@ -129,10 +129,10 @@ export async function captureCommandOutput(command, args = [], options = {}) {
   })
 }
 
-export function spawnCommand(command, args = [], options = {}) {
-  const { cwd, dryRun = false, env } = options
-
-  logger.info(`$ ${formatCommand(command, args)}`)
+export function spawnCommand(command, args = [], options = {}) {
+  const { cwd, dryRun = false, env } = options
+
+  logger.info(`$ ${formatCommand(command, args)}`)
 
   if (dryRun) {
     return null
@@ -141,6 +141,7 @@ export function spawnCommand(command, args = [], options = {}) {
   return spawn(command, args, {
     cwd,
     env: env ? { ...process.env, ...env } : process.env,
+    detached: process.platform !== "win32",
     stdio: "inherit",
     shell: shouldUseShell(command)
   })
@@ -166,31 +167,120 @@ export function waitForProcessExit(child, label) {
   })
 }
 
-export function registerChildCleanup(children) {
-  const activeChildren = children.filter(Boolean)
-
-  const cleanup = () => {
-    for (const child of activeChildren) {
-      if (child.exitCode === null && !child.killed) {
-        child.kill("SIGTERM")
-      }
-    }
-  }
-
-  const handleSignal = () => {
-    cleanup()
-    process.exit(0)
-  }
-
-  process.on("SIGINT", handleSignal)
-  process.on("SIGTERM", handleSignal)
-
-  return () => {
-    process.off("SIGINT", handleSignal)
-    process.off("SIGTERM", handleSignal)
-    cleanup()
-  }
-}
+export function registerChildCleanup(children) {
+  const activeChildren = children.filter(Boolean)
+  let cleanupPromise = null
+
+  const waitForChildExit = (child, timeoutMs = 3000) =>
+    new Promise((resolve) => {
+      if (!child || child.exitCode !== null || child.signalCode !== null) {
+        resolve(true)
+        return
+      }
+
+      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)
+    })
+
+  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.
+        }
+      }
+
+      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 = () => {
+    void cleanup().finally(() => {
+      process.exit(0)
+    })
+  }
+
+  process.on("SIGINT", handleSignal)
+  process.on("SIGTERM", handleSignal)
+
+  return async () => {
+    process.off("SIGINT", handleSignal)
+    process.off("SIGTERM", handleSignal)
+    await cleanup()
+  }
+}
 
 export async function waitForUrl(url, options = {}) {
   const { intervalMs = 250, timeoutMs = 15000 } = options