reset-framework-cli 1.1.4 → 1.2.0

package/src/lib/output.js

@@ -1,13 +1,13 @@
-import path from "node:path"
-import { cp, mkdir, readdir, rm, writeFile } from "node:fs/promises"
-import { existsSync } from "node:fs"
-
-import { logger } from "./logger.js"
-import { runCommand } from "./process.js"
-import {
-  resolveFrameworkRuntimeBinary,
-  resolveFrameworkRuntimeOutputDir
-} from "./project.js"
+import path from "node:path"
+import { cp, mkdir, readdir, rm, writeFile } from "node:fs/promises"
+import { existsSync } from "node:fs"
+
+import { logger } from "./logger.js"
+import { runCommand } from "./process.js"
+import {
+  resolveFrameworkRuntimeBinary,
+  resolveFrameworkRuntimeOutputDir
+} from "./project.js"
 
 function escapePlistString(value) {
   return value
@@ -60,7 +60,7 @@ function serializePlistValue(value, indentLevel = 1) {
   return `${indent}<string>${escapePlistString(String(value))}</string>\n`
 }
 
-function buildMacOSInfoPlist(config) {
+function buildMacOSInfoPlist(config) {
   const urlTypes = Array.isArray(config.protocols?.schemes)
     ? config.protocols.schemes.map((schemeConfig) => ({
         CFBundleTypeRole: schemeConfig.role ?? "Viewer",
@@ -95,39 +95,84 @@ function buildMacOSInfoPlist(config) {
     `<plist version="1.0">\n` +
     serializePlistValue(plist, 0) +
     `</plist>\n`
-  )
-}
+  )
+}
+
+function shouldCopyWindowsRuntimeArtifact(entryName) {
+  const extension = path.extname(entryName).toLowerCase()
+
+  return [
+    ".bin",
+    ".dat",
+    ".dll",
+    ".exe",
+    ".json",
+    ".manifest",
+    ".pak",
+    ".pri"
+  ].includes(extension)
+}
+
+function escapePowerShellLiteral(value) {
+  return String(value).replaceAll("'", "''")
+}
+
+export async function stageMacOSAppBundle(frameworkPaths, frameworkBuildPaths, config, options = {}) {
+  const { dryRun = false, outputPaths, configPath, preferSource = false } = options
+  const runtimeSourceBundle = resolveFrameworkRuntimeOutputDir(frameworkPaths, frameworkBuildPaths, "release", {
+    mustExist: !dryRun,
+    preferSource
+  })
 
-function shouldCopyWindowsRuntimeArtifact(entryName) {
-  const extension = path.extname(entryName).toLowerCase()
+  if (!outputPaths) {
+    throw new Error("stageMacOSAppBundle requires resolved output paths")
+  }
 
-  return [
-    ".bin",
-    ".dat",
-    ".dll",
-    ".exe",
-    ".json",
-    ".manifest",
-    ".pak",
-    ".pri"
-  ].includes(extension)
-}
+  if (!existsSync(outputPaths.frontendEntryFile) && !dryRun) {
+    throw new Error(
+      `Missing frontend build output at ${outputPaths.frontendEntryFile}. Run the frontend build first.`
+    )
+  }
+
+  logger.info(`Staging app bundle into ${outputPaths.appBundlePath}`)
 
-function escapePowerShellLiteral(value) {
-  return String(value).replaceAll("'", "''")
-}
+  if (dryRun) {
+    logger.info(`- copy ${runtimeSourceBundle} -> ${outputPaths.appBundlePath}`)
+    logger.info(`- copy ${configPath} -> ${outputPaths.bundledConfigPath}`)
+    logger.info(`- copy ${outputPaths.frontendDistDir} -> ${outputPaths.bundledFrontendDir}`)
+    return outputPaths
+  }
 
-export async function stageMacOSAppBundle(frameworkBuildPaths, appPaths, config, options = {}) {
-  const { dryRun = false, outputPaths, configPath } = options
+  await mkdir(outputPaths.macosDir, { recursive: true })
+  await rm(outputPaths.appBundlePath, { recursive: true, force: true })
+  await cp(runtimeSourceBundle, outputPaths.appBundlePath, { recursive: true })
 
-  if (!outputPaths) {
-    throw new Error("stageMacOSAppBundle requires resolved output paths")
-  }
+  await mkdir(outputPaths.resourcesDir, { recursive: true })
+  await cp(configPath, outputPaths.bundledConfigPath, { force: true })
+  await rm(outputPaths.bundledFrontendDir, { recursive: true, force: true })
+  await cp(outputPaths.frontendDistDir, outputPaths.bundledFrontendDir, { recursive: true })
+  await writeFile(
+    path.join(outputPaths.appBundlePath, "Contents", "Info.plist"),
+    buildMacOSInfoPlist(config),
+    "utf8"
+  )
 
-  if (!existsSync(frameworkBuildPaths.releaseAppTemplate) && !dryRun) {
-    throw new Error(
-      `Missing runtime app bundle at ${frameworkBuildPaths.releaseAppTemplate}. Run reset-framework-cli build first.`
-    )
+  return outputPaths
+}
+
+export async function stageWindowsAppBundle(frameworkPaths, frameworkBuildPaths, config, options = {}) {
+  const { dryRun = false, outputPaths, configPath, preferSource = false } = options
+  const runtimeSourceBinary = resolveFrameworkRuntimeBinary(frameworkPaths, frameworkBuildPaths, "release", {
+    mustExist: !dryRun,
+    preferSource
+  })
+  const runtimeSourceDir = resolveFrameworkRuntimeOutputDir(frameworkPaths, frameworkBuildPaths, "release", {
+    mustExist: !dryRun,
+    preferSource
+  })
+
+  if (!outputPaths) {
+    throw new Error("stageWindowsAppBundle requires resolved output paths")
   }
 
   if (!existsSync(outputPaths.frontendEntryFile) && !dryRun) {
@@ -136,91 +181,46 @@ export async function stageMacOSAppBundle(frameworkBuildPaths, appPaths, config,
     )
   }
 
-  logger.info(`Staging app bundle into ${outputPaths.appBundlePath}`)
+  logger.info(`Staging Windows app into ${outputPaths.appBundlePath}`)
 
   if (dryRun) {
-    logger.info(`- copy ${frameworkBuildPaths.releaseAppTemplate} -> ${outputPaths.appBundlePath}`)
+    logger.info(`- copy ${runtimeSourceDir} -> ${outputPaths.appBundlePath}`)
+    logger.info(`- rename ${runtimeSourceBinary} -> ${outputPaths.appExecutablePath}`)
     logger.info(`- copy ${configPath} -> ${outputPaths.bundledConfigPath}`)
     logger.info(`- copy ${outputPaths.frontendDistDir} -> ${outputPaths.bundledFrontendDir}`)
     return outputPaths
   }
 
-  await mkdir(outputPaths.macosDir, { recursive: true })
+  await mkdir(outputPaths.windowsDir, { recursive: true })
   await rm(outputPaths.appBundlePath, { recursive: true, force: true })
-  await cp(frameworkBuildPaths.releaseAppTemplate, outputPaths.appBundlePath, { recursive: true })
+  await mkdir(outputPaths.appBundlePath, { recursive: true })
+  const runtimeEntries = await readdir(runtimeSourceDir, { withFileTypes: true })
+  const runtimeBinaryName = path.basename(runtimeSourceBinary)
+
+  for (const entry of runtimeEntries) {
+    if (!entry.isDirectory() && !shouldCopyWindowsRuntimeArtifact(entry.name)) {
+      continue
+    }
+
+    const sourcePath = path.join(runtimeSourceDir, entry.name)
+    const targetPath =
+      entry.name.toLowerCase() === runtimeBinaryName.toLowerCase()
+        ? outputPaths.appExecutablePath
+        : path.join(outputPaths.appBundlePath, entry.name)
+
+    await cp(sourcePath, targetPath, { recursive: true, force: true })
+  }
 
   await mkdir(outputPaths.resourcesDir, { recursive: true })
   await cp(configPath, outputPaths.bundledConfigPath, { force: true })
   await rm(outputPaths.bundledFrontendDir, { recursive: true, force: true })
   await cp(outputPaths.frontendDistDir, outputPaths.bundledFrontendDir, { recursive: true })
-  await writeFile(
-    path.join(outputPaths.appBundlePath, "Contents", "Info.plist"),
-    buildMacOSInfoPlist(config),
-    "utf8"
-  )
 
-  return outputPaths
-}
-
-export async function stageWindowsAppBundle(frameworkBuildPaths, appPaths, config, options = {}) {
-  const { dryRun = false, outputPaths, configPath } = options
-  const runtimeSourceBinary = resolveFrameworkRuntimeBinary(frameworkBuildPaths, "release", {
-    mustExist: !dryRun
-  })
-  const runtimeSourceDir = resolveFrameworkRuntimeOutputDir(frameworkBuildPaths, "release", {
-    mustExist: !dryRun
-  })
-
-  if (!outputPaths) {
-    throw new Error("stageWindowsAppBundle requires resolved output paths")
-  }
-
-  if (!existsSync(outputPaths.frontendEntryFile) && !dryRun) {
-    throw new Error(
-      `Missing frontend build output at ${outputPaths.frontendEntryFile}. Run the frontend build first.`
-    )
-  }
-
-  logger.info(`Staging Windows app into ${outputPaths.appBundlePath}`)
-
-  if (dryRun) {
-    logger.info(`- copy ${runtimeSourceDir} -> ${outputPaths.appBundlePath}`)
-    logger.info(`- rename ${runtimeSourceBinary} -> ${outputPaths.appExecutablePath}`)
-    logger.info(`- copy ${configPath} -> ${outputPaths.bundledConfigPath}`)
-    logger.info(`- copy ${outputPaths.frontendDistDir} -> ${outputPaths.bundledFrontendDir}`)
-    return outputPaths
-  }
-
-  await mkdir(outputPaths.windowsDir, { recursive: true })
-  await rm(outputPaths.appBundlePath, { recursive: true, force: true })
-  await mkdir(outputPaths.appBundlePath, { recursive: true })
-  const runtimeEntries = await readdir(runtimeSourceDir, { withFileTypes: true })
-  const runtimeBinaryName = path.basename(runtimeSourceBinary)
-
-  for (const entry of runtimeEntries) {
-    if (!entry.isDirectory() && !shouldCopyWindowsRuntimeArtifact(entry.name)) {
-      continue
-    }
-
-    const sourcePath = path.join(runtimeSourceDir, entry.name)
-    const targetPath =
-      entry.name.toLowerCase() === runtimeBinaryName.toLowerCase()
-        ? outputPaths.appExecutablePath
-        : path.join(outputPaths.appBundlePath, entry.name)
-
-    await cp(sourcePath, targetPath, { recursive: true, force: true })
-  }
-
-  await mkdir(outputPaths.resourcesDir, { recursive: true })
-  await cp(configPath, outputPaths.bundledConfigPath, { force: true })
-  await rm(outputPaths.bundledFrontendDir, { recursive: true, force: true })
-  await cp(outputPaths.frontendDistDir, outputPaths.bundledFrontendDir, { recursive: true })
-
-  return outputPaths
-}
+  return outputPaths
+}
 
-export async function createMacOSZipArchive(outputPaths, options = {}) {
-  const { dryRun = false } = options
+export async function createMacOSZipArchive(outputPaths, options = {}) {
+  const { dryRun = false } = options
 
   logger.info(`Packaging ${outputPaths.appBundlePath} -> ${outputPaths.zipPath}`)
 
@@ -232,37 +232,37 @@ export async function createMacOSZipArchive(outputPaths, options = {}) {
     await mkdir(outputPaths.packagesDir, { recursive: true })
   }
 
-  await runCommand(
-    "ditto",
-    ["-c", "-k", "--sequesterRsrc", "--keepParent", outputPaths.appBundlePath, outputPaths.zipPath],
-    { dryRun }
-  )
-}
-
-export async function createWindowsZipArchive(outputPaths, options = {}) {
-  const { dryRun = false } = options
-
-  logger.info(`Packaging ${outputPaths.appBundlePath} -> ${outputPaths.zipPath}`)
-
-  if (process.platform !== "win32") {
-    throw new Error("Packaging is only implemented for Windows and macOS right now")
-  }
-
-  if (!dryRun) {
-    await mkdir(outputPaths.packagesDir, { recursive: true })
-    await rm(outputPaths.zipPath, { force: true })
-  }
-
-  const literalSourcePath = escapePowerShellLiteral(outputPaths.appBundlePath)
-  const literalDestinationPath = escapePowerShellLiteral(outputPaths.zipPath)
-  const archiveCommand = [
-    "$ErrorActionPreference = 'Stop'",
-    `Compress-Archive -LiteralPath '${literalSourcePath}' -DestinationPath '${literalDestinationPath}' -CompressionLevel Optimal`
-  ].join("; ")
-
-  await runCommand(
-    "powershell.exe",
-    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", archiveCommand],
-    { dryRun }
-  )
-}
+  await runCommand(
+    "ditto",
+    ["-c", "-k", "--sequesterRsrc", "--keepParent", outputPaths.appBundlePath, outputPaths.zipPath],
+    { dryRun }
+  )
+}
+
+export async function createWindowsZipArchive(outputPaths, options = {}) {
+  const { dryRun = false } = options
+
+  logger.info(`Packaging ${outputPaths.appBundlePath} -> ${outputPaths.zipPath}`)
+
+  if (process.platform !== "win32") {
+    throw new Error("Packaging is only implemented for Windows and macOS right now")
+  }
+
+  if (!dryRun) {
+    await mkdir(outputPaths.packagesDir, { recursive: true })
+    await rm(outputPaths.zipPath, { force: true })
+  }
+
+  const literalSourcePath = escapePowerShellLiteral(outputPaths.appBundlePath)
+  const literalDestinationPath = escapePowerShellLiteral(outputPaths.zipPath)
+  const archiveCommand = [
+    "$ErrorActionPreference = 'Stop'",
+    `Compress-Archive -LiteralPath '${literalSourcePath}' -DestinationPath '${literalDestinationPath}' -CompressionLevel Optimal`
+  ].join("; ")
+
+  await runCommand(
+    "powershell.exe",
+    ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", archiveCommand],
+    { dryRun }
+  )
+}

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"
 
@@ -44,32 +44,32 @@ export function getInstallCommandArgs(packageManager = "npm") {
   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)}`)
+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
   }
 
-  await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      env: env ? { ...process.env, ...env } : process.env,
-      stdio: "inherit",
-      shell: shouldUseShell(command)
-    })
-
-    child.once("error", reject)
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: env ? { ...process.env, ...env } : process.env,
+      stdio: "inherit",
+      shell: shouldUseShell(command)
+    })
+
+    child.once("error", reject)
     child.once("exit", (code, signal) => {
       if (code === 0) {
         resolve(undefined)
@@ -92,13 +92,13 @@ export async function captureCommandOutput(command, args = [], 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"],
-      shell: shouldUseShell(command)
-    })
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: env ? { ...process.env, ...env } : process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: shouldUseShell(command)
+    })
 
     let stdout = ""
     let stderr = ""
@@ -138,13 +138,14 @@ export function spawnCommand(command, args = [], options = {}) {
     return null
   }
 
-  return spawn(command, args, {
-    cwd,
-    env: env ? { ...process.env, ...env } : process.env,
-    stdio: "inherit",
-    shell: shouldUseShell(command)
-  })
-}
+  return spawn(command, args, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    detached: process.platform !== "win32",
+    stdio: "inherit",
+    shell: shouldUseShell(command)
+  })
+}
 
 export function waitForProcessExit(child, label) {
   return new Promise((resolve, reject) => {
@@ -168,27 +169,116 @@ export function waitForProcessExit(child, label) {
 
 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 cleanup = () => {
-    for (const child of activeChildren) {
-      if (child.exitCode === null && !child.killed) {
-        child.kill("SIGTERM")
+      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 = () => {
-    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()
   }
 }