reset-framework-cli 1.1.4 → 1.2.0

package/src/commands/init.js

@@ -176,89 +176,6 @@ 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"
 
 function listTemplates(templatesDir) {
@@ -387,6 +304,28 @@ 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)) {
     return
@@ -493,10 +432,10 @@ function createRootPackageJson(options) {
 
   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"
+    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
@@ -544,10 +483,6 @@ async function writeRootPackageFiles(options) {
       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")
   }
 }
 
@@ -846,11 +781,6 @@ 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")],

package/src/commands/package.js

@@ -1,9 +1,9 @@
-import { existsSync } from "node:fs"
-
-import { createMacOSZipArchive, createWindowsZipArchive } from "../lib/output.js"
-import {
-  assertAppProject,
-  loadResetConfig,
+import { existsSync } from "node:fs"
+
+import { createMacOSZipArchive, createWindowsZipArchive } from "../lib/output.js"
+import {
+  assertAppProject,
+  loadResetConfig,
   resolveAppOutputPaths,
   resolveAppPaths
 } from "../lib/project.js"
@@ -15,17 +15,17 @@ import {
   printStatusTable
 } from "../lib/ui.js"
 
-export const description = "Package the built desktop app into a distributable archive"
-
-export async function run(context) {
-  const dryRun = Boolean(context.flags["dry-run"])
-  const isWindows = process.platform === "win32"
-  const archiveBuilder = isWindows ? createWindowsZipArchive : createMacOSZipArchive
-  const archiveDescription = isWindows
-    ? "Create a Windows zip package from the built app folder"
-    : "Create a macOS zip package from the built app bundle"
-  const appPaths = resolveAppPaths(context.projectRoot)
-  assertAppProject(appPaths)
+export const description = "Package the built desktop app into a distributable archive"
+
+export async function run(context) {
+  const dryRun = Boolean(context.flags["dry-run"])
+  const isWindows = process.platform === "win32"
+  const archiveBuilder = isWindows ? createWindowsZipArchive : createMacOSZipArchive
+  const archiveDescription = isWindows
+    ? "Create a Windows zip package from the built app folder"
+    : "Create a macOS zip package from the built app bundle"
+  const appPaths = resolveAppPaths(context.projectRoot)
+  assertAppProject(appPaths)
 
   const config = loadResetConfig(appPaths)
   assertAppProject(appPaths, config)
@@ -38,11 +38,11 @@ export async function run(context) {
     ["Archive", outputPaths.zipPath]
   ])
   console.log("")
-
-  printSection("Plan")
-  printStatusTable([
-    ["ready", "Archive", archiveDescription]
-  ])
+
+  printSection("Plan")
+  printStatusTable([
+    ["ready", "Archive", archiveDescription]
+  ])
 
   if (!existsSync(outputPaths.appBundlePath) && !dryRun) {
     throw new Error(
@@ -56,11 +56,11 @@ export async function run(context) {
     printStatusTable([["plan", "Package", "No archive will be written"]])
     return
   }
-
-  console.log("")
-  const progress = createProgress(1, "Package")
-  await archiveBuilder(outputPaths, { dryRun })
-  progress.tick("Archive created")
+
+  console.log("")
+  const progress = createProgress(1, "Package")
+  await archiveBuilder(outputPaths, { dryRun })
+  progress.tick("Archive created")
 
   console.log("")
   printSection("Result")

package/src/index.js

@@ -16,15 +16,16 @@ import {
 } from "./lib/ui.js"
 
 const commands = {
-  build: {
-    description: buildDescription,
-    usage: "reset-framework-cli build [--skip-frontend] [--skip-runtime] [--skip-stage] [--dry-run]",
-    options: [
-      ["--skip-frontend", "Skip the frontend build step"],
-      ["--skip-runtime", "Skip the release runtime build"],
-      ["--skip-stage", "Skip assembling the final .app bundle"],
-      ["--dry-run", "Print the build plan without running commands"]
-    ],
+  build: {
+    description: buildDescription,
+    usage: "reset-framework-cli build [--skip-frontend] [--skip-runtime] [--skip-stage] [--runtime-source] [--dry-run]",
+    options: [
+      ["--skip-frontend", "Skip the frontend build step"],
+      ["--skip-runtime", "Skip the release runtime build"],
+      ["--skip-stage", "Skip assembling the final .app bundle"],
+      ["--runtime-source", "Build the runtime from @reset-framework/native instead of using a bundled runtime package"],
+      ["--dry-run", "Print the build plan without running commands"]
+    ],
     examples: [
       "reset-framework-cli build",
       "reset-framework-cli build --dry-run"
@@ -56,15 +57,16 @@ const commands = {
     ],
     run: runCreateApp
   },
-  dev: {
-    description: devDescription,
-    usage: "reset-framework-cli dev [--skip-frontend] [--skip-runtime] [--no-open] [--dry-run]",
-    options: [
-      ["--skip-frontend", "Reuse an already running frontend dev server"],
-      ["--skip-runtime", "Reuse an existing native dev build"],
-      ["--no-open", "Do not launch the desktop window after startup"],
-      ["--dry-run", "Print the dev plan without starting processes"]
-    ],
+  dev: {
+    description: devDescription,
+    usage: "reset-framework-cli dev [--skip-frontend] [--skip-runtime] [--no-open] [--runtime-source] [--dry-run]",
+    options: [
+      ["--skip-frontend", "Reuse an already running frontend dev server"],
+      ["--skip-runtime", "Reuse an existing native dev build"],
+      ["--no-open", "Do not launch the desktop window after startup"],
+      ["--runtime-source", "Build the runtime from @reset-framework/native instead of using a bundled runtime package"],
+      ["--dry-run", "Print the dev plan without starting processes"]
+    ],
     examples: [
       "reset-framework-cli dev",
       "reset-framework-cli dev --skip-runtime"

package/src/lib/framework.js

@@ -3,7 +3,8 @@ import { rm } from "node:fs/promises"
 import { readFile } from "node:fs/promises"
 import path from "node:path"
 
-import { captureCommandOutput, runCommand } from "./process.js"
+import { assertFrameworkSourceInstall, resolveFrameworkRuntimeStrategy } from "./project.js"
+import { runCommand } from "./process.js"
 import { ensureVcpkgToolchain } from "./toolchain.js"
 
 function getBuildDirectory(frameworkBuildPaths, mode) {
@@ -16,6 +17,11 @@ function getBuildType(mode) {
   return mode === "release" ? "Release" : "Debug"
 }
 
+function readCmakeCacheValue(cacheContents, key) {
+  const match = cacheContents.match(new RegExp(`^${key}:[^=]+=(.+)$`, "m"))
+  return match ? match[1].trim() : null
+}
+
 function getVsWherePath() {
   const candidates = [
     path.join(process.env["ProgramFiles(x86)"] ?? "", "Microsoft Visual Studio", "Installer", "vswhere.exe"),
@@ -25,36 +31,100 @@ function getVsWherePath() {
   return candidates.find((candidate) => candidate && existsSync(candidate)) ?? null
 }
 
+function getVisualStudioInstanceCandidates() {
+  const roots = [
+    path.join(process.env.ProgramFiles ?? "", "Microsoft Visual Studio", "2022"),
+    path.join(process.env["ProgramFiles(x86)"] ?? "", "Microsoft Visual Studio", "2022"),
+    path.join(process.env.ProgramFiles ?? "", "Microsoft Visual Studio", "2019"),
+    path.join(process.env["ProgramFiles(x86)"] ?? "", "Microsoft Visual Studio", "2019")
+  ]
+  const editions = ["BuildTools", "Community", "Professional", "Enterprise", "Preview"]
+  const candidates = []
+
+  for (const root of roots) {
+    if (!root || !existsSync(root)) {
+      continue
+    }
+
+    for (const edition of editions) {
+      const candidate = path.join(root, edition)
+      if (existsSync(candidate)) {
+        candidates.push(candidate)
+      }
+    }
+  }
+
+  return candidates
+}
+
 async function findVisualStudioGenerator() {
+  const instanceCandidates = getVisualStudioInstanceCandidates()
+
+  if (instanceCandidates.some((candidate) => candidate.includes(`${path.sep}2022${path.sep}`))) {
+    return {
+      generator: "Visual Studio 17 2022",
+      instance: instanceCandidates.find((candidate) => candidate.includes(`${path.sep}2022${path.sep}`))
+    }
+  }
+
+  if (instanceCandidates.some((candidate) => candidate.includes(`${path.sep}2019${path.sep}`))) {
+    return {
+      generator: "Visual Studio 16 2019",
+      instance: instanceCandidates.find((candidate) => candidate.includes(`${path.sep}2019${path.sep}`))
+    }
+  }
+
   const vswherePath = getVsWherePath()
   if (!vswherePath) {
     return null
   }
 
-  try {
-    const version = await captureCommandOutput(vswherePath, [
+  const { captureCommandOutput } = await import("./process.js")
+  const version = await captureCommandOutput(vswherePath, [
+    "-latest",
+    "-products",
+    "*",
+    "-requires",
+    "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+    "-property",
+    "catalog_productLineVersion"
+  ]).catch(() => "")
+
+  if (version === "2022") {
+    const instance = await captureCommandOutput(vswherePath, [
       "-latest",
       "-products",
       "*",
       "-requires",
       "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
       "-property",
-      "catalog_productLineVersion"
-    ])
+      "installationPath"
+    ]).catch(() => "")
 
-    const normalized = String(version).trim()
-    if (normalized === "2022") {
-      return "Visual Studio 17 2022"
+    return {
+      generator: "Visual Studio 17 2022",
+      instance: instance || null
     }
+  }
+
+  if (version === "2019") {
+    const instance = await captureCommandOutput(vswherePath, [
+      "-latest",
+      "-products",
+      "*",
+      "-requires",
+      "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+      "-property",
+      "installationPath"
+    ]).catch(() => "")
 
-    if (normalized === "2019") {
-      return "Visual Studio 16 2019"
+    return {
+      generator: "Visual Studio 16 2019",
+      instance: instance || null
     }
-  } catch {
-    // Fall through to the default Windows generator if detection fails.
   }
 
-  return "Visual Studio 17 2022"
+  return null
 }
 
 async function resolveCmakeGenerator() {
@@ -62,35 +132,36 @@ async function resolveCmakeGenerator() {
     typeof process.env.CMAKE_GENERATOR === "string" && process.env.CMAKE_GENERATOR.trim() !== ""
       ? process.env.CMAKE_GENERATOR.trim()
       : null
-
-  if (envGenerator) {
-    return {
-      name: envGenerator,
-      configureArgs: process.platform === "win32" &&
-        !process.env.CMAKE_GENERATOR_PLATFORM &&
-        envGenerator.startsWith("Visual Studio ")
-        ? ["-G", envGenerator, "-A", "x64"]
-        : ["-G", envGenerator],
-      buildArgs: envGenerator.startsWith("Visual Studio ")
-        ? ["--config"]
-        : [],
+
+  if (envGenerator) {
+    return {
+      name: envGenerator,
+      configureArgs: process.platform === "win32" &&
+        !process.env.CMAKE_GENERATOR_PLATFORM &&
+        envGenerator.startsWith("Visual Studio ")
+        ? ["-G", envGenerator, "-A", "x64"]
+        : ["-G", envGenerator],
+      buildArgs: envGenerator.startsWith("Visual Studio ")
+        ? ["--config"]
+        : [],
       multiConfig: envGenerator.startsWith("Visual Studio ")
     }
   }
 
   if (process.platform === "win32") {
-    const generator = await findVisualStudioGenerator()
-    if (!generator) {
-      throw new Error(
-        "Could not find a supported Visual Studio C++ installation. Install Visual Studio Build Tools or set CMAKE_GENERATOR manually."
-      )
-    }
+    const visualStudio = await findVisualStudioGenerator()
+    if (visualStudio) {
+      const configureArgs = ["-G", visualStudio.generator, "-A", "x64"]
+      if (visualStudio.instance) {
+        configureArgs.push(`-DCMAKE_GENERATOR_INSTANCE=${visualStudio.instance}`)
+      }
 
-    return {
-      name: generator,
-      configureArgs: ["-G", generator, "-A", "x64"],
-      buildArgs: ["--config"],
-      multiConfig: true
+      return {
+        name: visualStudio.generator,
+        configureArgs,
+        buildArgs: ["--config"],
+        multiConfig: true
+      }
     }
   }
 
@@ -99,79 +170,95 @@ async function resolveCmakeGenerator() {
     configureArgs: ["-G", "Ninja"],
     buildArgs: [],
     multiConfig: false
-  }
-}
-
-async function ensureMatchingCmakeSource(buildDir, frameworkRoot) {
+  }
+}
+
+async function ensureCompatibleCmakeBuild(buildDir, frameworkRoot, generatorName) {
   const cachePath = path.join(buildDir, "CMakeCache.txt")
   if (!existsSync(cachePath)) {
     return
   }
-
-  let cache
-  try {
-    cache = await readFile(cachePath, "utf8")
-  } catch {
-    return
-  }
-
-  const match = cache.match(/^CMAKE_HOME_DIRECTORY:INTERNAL=(.+)$/m)
-  if (!match) {
+
+  let cache
+  try {
+    cache = await readFile(cachePath, "utf8")
+  } catch {
+    return
+  }
+
+  const cachedRootValue = readCmakeCacheValue(cache, "CMAKE_HOME_DIRECTORY")
+  const cachedGenerator = readCmakeCacheValue(cache, "CMAKE_GENERATOR")
+  if (!cachedRootValue) {
     return
   }
 
-  const cachedRoot = path.resolve(match[1].trim())
+  const cachedRoot = path.resolve(cachedRootValue)
   const currentRoot = path.resolve(frameworkRoot)
+  const generatorChanged =
+    typeof cachedGenerator === "string" &&
+    cachedGenerator !== generatorName
 
-  if (cachedRoot !== currentRoot) {
+  if (cachedRoot !== currentRoot || generatorChanged) {
     await rm(buildDir, { recursive: true, force: true })
   }
 }
-
+
 export async function configureFrameworkBuild(frameworkPaths, frameworkBuildPaths, mode, options = {}) {
   const { dryRun = false, cwd } = options
+  assertFrameworkSourceInstall(frameworkPaths)
   const toolchainFile = await ensureVcpkgToolchain({ dryRun })
   const buildDir = getBuildDirectory(frameworkBuildPaths, mode)
   const generator = await resolveCmakeGenerator()
   if (!dryRun) {
-    await ensureMatchingCmakeSource(buildDir, frameworkPaths.frameworkRoot)
+    await ensureCompatibleCmakeBuild(buildDir, frameworkPaths.frameworkRoot, generator.name)
   }
-  const configureArgs = [
-    "-S",
-    frameworkPaths.frameworkRoot,
-    "-B",
-    buildDir,
-    ...generator.configureArgs,
-    `-DCMAKE_BUILD_TYPE=${getBuildType(mode)}`,
-    "-DCMAKE_CXX_STANDARD=20",
-    "-DCMAKE_CXX_STANDARD_REQUIRED=ON",
-    "-DCMAKE_CXX_EXTENSIONS=OFF",
-    "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
-    `-DCMAKE_TOOLCHAIN_FILE=${toolchainFile}`
-  ]
-
-  try {
-    await runCommand("cmake", configureArgs, {
-      cwd,
-      dryRun
-    })
-  } catch (error) {
-    throw error
+  const configureArgs = [
+    "-S",
+    frameworkPaths.frameworkRoot,
+    "-B",
+    buildDir,
+    ...generator.configureArgs,
+    `-DCMAKE_BUILD_TYPE=${getBuildType(mode)}`,
+    "-DCMAKE_CXX_STANDARD=20",
+    "-DCMAKE_CXX_STANDARD_REQUIRED=ON",
+    "-DCMAKE_CXX_EXTENSIONS=OFF",
+    "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+    `-DCMAKE_TOOLCHAIN_FILE=${toolchainFile}`
+  ]
+
+  try {
+    await runCommand("cmake", configureArgs, {
+      cwd,
+      dryRun
+    })
+  } catch (error) {
+    throw error
   }
 }
-
-export async function buildFrameworkRuntime(frameworkPaths, frameworkBuildPaths, mode, options = {}) {
+
+async function buildFrameworkRuntimeFromSource(frameworkPaths, frameworkBuildPaths, mode, options = {}) {
   const { dryRun = false, cwd } = options
   const buildDir = getBuildDirectory(frameworkBuildPaths, mode)
   const generator = await resolveCmakeGenerator()
-
-  await configureFrameworkBuild(frameworkPaths, frameworkBuildPaths, mode, {
-    cwd,
-    dryRun
-  })
+
+  await configureFrameworkBuild(frameworkPaths, frameworkBuildPaths, mode, {
+    cwd,
+    dryRun
+  })
 
   await runCommand("cmake", ["--build", buildDir, ...generator.buildArgs, ...(generator.multiConfig ? [getBuildType(mode)] : [])], {
     cwd,
     dryRun
   })
 }
+
+export async function prepareFrameworkRuntime(frameworkPaths, frameworkBuildPaths, mode, options = {}) {
+  const strategy = resolveFrameworkRuntimeStrategy(frameworkPaths, options)
+
+  if (strategy.kind === "prebuilt") {
+    return strategy
+  }
+
+  await buildFrameworkRuntimeFromSource(frameworkPaths, frameworkBuildPaths, mode, options)
+  return strategy
+}