reset-framework-cli 0.2.0

package/src/lib/project.js

@@ -0,0 +1,357 @@
+import { existsSync, readFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const require = createRequire(import.meta.url)
+
+function requireString(object, key, scope) {
+  if (typeof object?.[key] !== "string" || object[key].trim() === "") {
+    throw new Error(`Missing or invalid string field '${scope}.${key}'`)
+  }
+
+  return object[key]
+}
+
+function optionalString(object, key, fallback) {
+  if (object == null || !(key in object)) {
+    return fallback
+  }
+
+  if (typeof object[key] !== "string" || object[key].trim() === "") {
+    throw new Error(`Missing or invalid string field '${key}'`)
+  }
+
+  return object[key]
+}
+
+function optionalObject(object, key) {
+  if (object == null || !(key in object)) {
+    return {}
+  }
+
+  if (typeof object[key] !== "object" || object[key] === null || Array.isArray(object[key])) {
+    throw new Error(`Missing or invalid object field '${key}'`)
+  }
+
+  return object[key]
+}
+
+function sanitizeName(value) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "reset-app"
+}
+
+function normalizeFrontendDir(value) {
+  const trimmed = value.trim()
+
+  if (trimmed === "." || trimmed === "./") {
+    return "."
+  }
+
+  if (path.isAbsolute(trimmed)) {
+    throw new Error("project.frontendDir must be a relative path")
+  }
+
+  const normalized = path.normalize(trimmed).replace(/\\/g, "/").replace(/\/+$/g, "")
+
+  if (normalized === "" || normalized === ".") {
+    return "."
+  }
+
+  if (normalized.startsWith("../")) {
+    throw new Error("project.frontendDir cannot point outside the app root")
+  }
+
+  return normalized
+}
+
+function normalizeStyling(value) {
+  if (value === "css" || value === "tailwindcss") {
+    return value
+  }
+
+  throw new Error("project.styling must be either 'css' or 'tailwindcss'")
+}
+
+function toTitleCase(value) {
+  return value
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join(" ") || "Reset App"
+}
+
+function readJsonFile(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"))
+}
+
+function isPathInside(parentDir, candidatePath) {
+  const relative = path.relative(parentDir, candidatePath)
+  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
+}
+
+function resolvePackageInfo(packageName, fallbackRoot) {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageRoot = path.dirname(packageJsonPath)
+    const manifest = readJsonFile(packageJsonPath)
+
+    return {
+      packageName: manifest.name ?? packageName,
+      packageRoot,
+      packageJsonPath,
+      version: manifest.version ?? "0.0.0",
+      localFallback: false
+    }
+  } catch {
+    const packageJsonPath = path.join(fallbackRoot, "package.json")
+    const manifest = readJsonFile(packageJsonPath)
+
+    return {
+      packageName: manifest.name ?? packageName,
+      packageRoot: fallbackRoot,
+      packageJsonPath,
+      version: manifest.version ?? "0.0.0",
+      localFallback: true
+    }
+  }
+}
+
+export function resolveFrameworkPaths() {
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url))
+  const cliDir = path.resolve(moduleDir, "../..")
+  const packagesDir = path.resolve(cliDir, "..")
+  const nativePackage = resolvePackageInfo(
+    "@reset-framework/native",
+    path.join(packagesDir, "native")
+  )
+  const sdkPackage = resolvePackageInfo(
+    "@reset-framework/sdk",
+    path.join(packagesDir, "sdk")
+  )
+  const schemaPackage = resolvePackageInfo(
+    "@reset-framework/schema",
+    path.join(packagesDir, "schema")
+  )
+  const isWorkspaceLayout = [nativePackage, sdkPackage, schemaPackage].every((pkg) =>
+    isPathInside(packagesDir, pkg.packageRoot)
+  )
+
+  return {
+    cliDir,
+    packagesDir,
+    frameworkRoot: nativePackage.packageRoot,
+    frameworkPackage: nativePackage,
+    isWorkspaceLayout,
+    sdkPackage,
+    schemaPackage,
+    runtimeDir: path.join(nativePackage.packageRoot, "runtime"),
+    rootCMakePath: path.join(nativePackage.packageRoot, "CMakeLists.txt"),
+    cmakePresetsPath: path.join(nativePackage.packageRoot, "CMakePresets.json"),
+    vcpkgManifestPath: path.join(nativePackage.packageRoot, "vcpkg.json"),
+    templatesDir: path.join(cliDir, "templates"),
+  }
+}
+
+export function resolveFrameworkBuildPaths(appPaths) {
+  const frameworkCacheRoot = path.join(appPaths.appRoot, ".reset", "framework")
+
+  return {
+    frameworkCacheRoot,
+    devBuildDir: path.join(frameworkCacheRoot, "build", "dev"),
+    releaseBuildDir: path.join(frameworkCacheRoot, "build", "release"),
+    devAppBinary: path.join(
+      frameworkCacheRoot,
+      "build",
+      "dev",
+      "runtime",
+      "reset-framework.app",
+      "Contents",
+      "MacOS",
+      "reset-framework"
+    ),
+    releaseAppTemplate: path.join(
+      frameworkCacheRoot,
+      "build",
+      "release",
+      "runtime",
+      "reset-framework.app"
+    )
+  }
+}
+
+export function resolveAppPaths(appRoot) {
+  return {
+    appRoot,
+    frontendDir: path.join(appRoot, "frontend"),
+    resetConfigPath: path.join(appRoot, "reset.config.json"),
+    legacyResetConfigPath: path.join(appRoot, "frontend", "reset.config.json")
+  }
+}
+
+export function resolveConfigPath(appPaths) {
+  if (existsSync(appPaths.resetConfigPath)) {
+    return appPaths.resetConfigPath
+  }
+
+  if (existsSync(appPaths.legacyResetConfigPath)) {
+    return appPaths.legacyResetConfigPath
+  }
+
+  return appPaths.resetConfigPath
+}
+
+export function getFrameworkChecks(frameworkPaths) {
+  return [
+    ["native", frameworkPaths.frameworkPackage.packageJsonPath],
+    ["sdk", frameworkPaths.sdkPackage.packageJsonPath],
+    ["schema", frameworkPaths.schemaPackage.packageJsonPath],
+    ["cmake", frameworkPaths.rootCMakePath],
+    ["runtime", frameworkPaths.runtimeDir],
+    ["vcpkg", frameworkPaths.vcpkgManifestPath],
+    ["templates", frameworkPaths.templatesDir]
+  ]
+}
+
+export function getAppChecks(appPaths) {
+  return [["config", resolveConfigPath(appPaths)]]
+}
+
+export function assertFrameworkInstall(frameworkPaths) {
+  const missing = getFrameworkChecks(frameworkPaths)
+    .filter(([, filePath]) => !existsSync(filePath))
+    .map(([label]) => label)
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Reset CLI installation is incomplete. Missing: ${missing.join(", ")}`
+    )
+  }
+}
+
+export function assertAppProject(appPaths, config) {
+  const checks = [...getAppChecks(appPaths)]
+
+  if (config) {
+    checks.unshift(["frontend", resolveFrontendDir(appPaths, config)])
+  }
+
+  const missing = checks
+    .filter(([, filePath]) => !existsSync(filePath))
+    .map(([label]) => label)
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Current directory does not look like a Reset app. Missing: ${missing.join(", ")}`
+    )
+  }
+}
+
+export function validateResetConfig(rawConfig) {
+  const frontend = optionalObject(rawConfig, "frontend")
+  const build = optionalObject(rawConfig, "build")
+  const project = optionalObject(rawConfig, "project")
+  const windowConfig = optionalObject(rawConfig, "window")
+
+  return {
+    ...rawConfig,
+    name: sanitizeName(requireString(rawConfig, "name", "config")),
+    productName: requireString(rawConfig, "productName", "config"),
+    appId: requireString(rawConfig, "appId", "config"),
+    version: requireString(rawConfig, "version", "config"),
+    window: {
+      title: optionalString(windowConfig, "title", "Reset App")
+    },
+    frontend: {
+      devUrl: requireString(frontend, "devUrl", "frontend"),
+      distDir: optionalString(frontend, "distDir", "dist"),
+      entryHtml: optionalString(frontend, "entryHtml", "index.html")
+    },
+    project: {
+      frontendDir: normalizeFrontendDir(optionalString(project, "frontendDir", "frontend")),
+      styling: normalizeStyling(optionalString(project, "styling", "css"))
+    },
+    build: {
+      outputDir: optionalString(build, "outputDir", ".reset/build")
+    }
+  }
+}
+
+export function loadResetConfig(appPaths) {
+  const configPath = resolveConfigPath(appPaths)
+  const raw = readFileSync(configPath, "utf8")
+
+  try {
+    return validateResetConfig(JSON.parse(raw))
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${configPath}: ${error.message}`)
+    }
+
+    throw error
+  }
+}
+
+export function resolveAppOutputPaths(appPaths, config) {
+  const outputRoot = path.resolve(appPaths.appRoot, config.build.outputDir)
+  const frontendDir = resolveFrontendDir(appPaths, config)
+  const appBundleName = `${config.productName}.app`
+  const macosDir = path.join(outputRoot, "macos")
+  const appBundlePath = path.join(macosDir, appBundleName)
+  const resourcesDir = path.join(appBundlePath, "Contents", "Resources")
+  const packagesDir = path.join(outputRoot, "packages")
+
+  return {
+    outputRoot,
+    macosDir,
+    appBundlePath,
+    resourcesDir,
+    bundledConfigPath: path.join(resourcesDir, "reset.config.json"),
+    bundledFrontendDir: path.join(resourcesDir, config.frontend.distDir),
+    frontendDistDir: path.resolve(frontendDir, config.frontend.distDir),
+    frontendEntryFile: path.resolve(
+      frontendDir,
+      config.frontend.distDir,
+      config.frontend.entryHtml
+    ),
+    packagesDir,
+    zipPath: path.join(packagesDir, `${config.name}-macos.zip`)
+  }
+}
+
+export function resolveFrontendDir(appPaths, config) {
+  return path.resolve(appPaths.appRoot, config.project.frontendDir)
+}
+
+export function resolveDevServerOptions(config) {
+  const url = new URL(config.frontend.devUrl)
+
+  return {
+    host: url.hostname,
+    port: url.port || "5173",
+    url: url.toString()
+  }
+}
+
+export function makeAppMetadata(appName) {
+  const name = sanitizeName(appName)
+  const productName = toTitleCase(appName)
+
+  return {
+    name,
+    productName,
+    appId: `com.example.${name}`,
+    title: productName
+  }
+}
+
+export function resolveSdkDependencySpec(frameworkPaths) {
+  if (frameworkPaths.isWorkspaceLayout || frameworkPaths.sdkPackage.localFallback) {
+    return `file:${frameworkPaths.sdkPackage.packageRoot}`
+  }
+
+  return `^${frameworkPaths.sdkPackage.version}`
+}

package/src/lib/toolchain.js

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+
+import { runCommand } from "./process.js"
+
+function toToolchainPath(root) {
+  return path.join(root, "scripts", "buildsystems", "vcpkg.cmake")
+}
+
+export function getVcpkgToolchainCandidates() {
+  const candidates = []
+
+  if (typeof process.env.CMAKE_TOOLCHAIN_FILE === "string" && process.env.CMAKE_TOOLCHAIN_FILE.trim() !== "") {
+    candidates.push(process.env.CMAKE_TOOLCHAIN_FILE)
+  }
+
+  if (typeof process.env.VCPKG_ROOT === "string" && process.env.VCPKG_ROOT.trim() !== "") {
+    candidates.push(toToolchainPath(process.env.VCPKG_ROOT))
+  }
+
+  candidates.push(toToolchainPath(path.join(homedir(), ".vcpkg")))
+  candidates.push(toToolchainPath(path.join(homedir(), ".reset-framework-cli", "vcpkg")))
+
+  return [...new Set(candidates)]
+}
+
+export function findVcpkgToolchainFile() {
+  return getVcpkgToolchainCandidates().find((candidate) => existsSync(candidate)) ?? null
+}
+
+export async function ensureVcpkgToolchain(options = {}) {
+  const { dryRun = false } = options
+  const existing = findVcpkgToolchainFile()
+
+  if (existing) {
+    return existing
+  }
+
+  const vcpkgRoot = path.join(homedir(), ".reset-framework-cli", "vcpkg")
+  const toolchainFile = toToolchainPath(vcpkgRoot)
+
+  if (!existsSync(vcpkgRoot)) {
+    await runCommand("git", ["clone", "https://github.com/microsoft/vcpkg", vcpkgRoot], {
+      dryRun
+    })
+  }
+
+  if (process.platform === "win32") {
+    await runCommand("cmd", ["/c", "bootstrap-vcpkg.bat", "-disableMetrics"], {
+      cwd: vcpkgRoot,
+      dryRun
+    })
+  } else {
+    await runCommand("bash", ["./bootstrap-vcpkg.sh", "-disableMetrics"], {
+      cwd: vcpkgRoot,
+      dryRun
+    })
+  }
+
+  return toolchainFile
+}

package/src/lib/ui.js

@@ -0,0 +1,244 @@
+import readline from "node:readline/promises"
+import { stdin as input, stdout as output } from "node:process"
+
+const ansi = {
+  reset: "\u001b[0m",
+  bold: "\u001b[1m",
+  dim: "\u001b[2m",
+  cyan: "\u001b[36m",
+  gray: "\u001b[90m",
+  green: "\u001b[32m",
+  yellow: "\u001b[33m",
+  red: "\u001b[31m"
+}
+
+function style(text, code) {
+  if (!output.isTTY) {
+    return text
+  }
+
+  return `${code}${text}${ansi.reset}`
+}
+
+export function isInteractiveSession() {
+  return Boolean(input.isTTY && output.isTTY)
+}
+
+export function bold(text) {
+  return style(text, ansi.bold)
+}
+
+export function dim(text) {
+  return style(text, ansi.dim)
+}
+
+export function accent(text) {
+  return style(text, ansi.cyan)
+}
+
+export function success(text) {
+  return style(text, ansi.green)
+}
+
+export function warning(text) {
+  return style(text, ansi.yellow)
+}
+
+export function danger(text) {
+  return style(text, ansi.red)
+}
+
+export function printBanner(title, subtitle) {
+  console.log(bold(title))
+  if (subtitle) {
+    console.log(dim(subtitle))
+  }
+  console.log("")
+}
+
+export function printSection(title) {
+  console.log(accent(title))
+}
+
+export function printMutedLine(text = "") {
+  console.log(dim(text))
+}
+
+export function printKeyValueTable(entries) {
+  if (entries.length === 0) {
+    return
+  }
+
+  const width = entries.reduce((max, [key]) => Math.max(max, key.length), 0)
+
+  for (const [key, value] of entries) {
+    console.log(`  ${dim(key.padEnd(width))}  ${value}`)
+  }
+}
+
+function formatStatus(status, width) {
+  const normalized = String(status).toLowerCase()
+  const padded = normalized.toUpperCase().padEnd(width)
+
+  if (normalized === "ok" || normalized === "done" || normalized === "ready") {
+    return success(padded)
+  }
+
+  if (normalized === "warn" || normalized === "skip") {
+    return warning(padded)
+  }
+
+  if (normalized === "missing" || normalized === "error") {
+    return danger(padded)
+  }
+
+  return accent(padded)
+}
+
+export function printStatusTable(entries) {
+  if (entries.length === 0) {
+    return
+  }
+
+  const statusWidth = entries.reduce((max, [status]) => Math.max(max, String(status).length), 0)
+  const labelWidth = entries.reduce((max, [, label]) => Math.max(max, label.length), 0)
+
+  for (const [status, label, detail = ""] of entries) {
+    const suffix = detail ? `  ${detail}` : ""
+    console.log(`  ${formatStatus(status, statusWidth)}  ${label.padEnd(labelWidth)}${suffix}`)
+  }
+}
+
+export function printCommandList(commands) {
+  if (commands.length === 0) {
+    return
+  }
+
+  const width = commands.reduce((max, command) => Math.max(max, command.name.length), 0)
+
+  for (const command of commands) {
+    console.log(`  ${bold(command.name.padEnd(width))}  ${command.description}`)
+  }
+}
+
+export function createProgress(total, label = "Progress") {
+  let current = 0
+  let lastWidth = 0
+
+  function render(message) {
+    const width = 24
+    const ratio = total === 0 ? 1 : current / total
+    const filled = Math.round(ratio * width)
+    const percentage = `${Math.round(ratio * 100)}`.padStart(3, " ")
+    const bar = `${"#".repeat(filled)}${"-".repeat(width - filled)}`
+    const line = `${dim(label)} [${bar}] ${percentage}% ${message}`
+
+    if (output.isTTY) {
+      const padded = line.padEnd(lastWidth, " ")
+      output.write(`\r${padded}`)
+      lastWidth = Math.max(lastWidth, line.length)
+      if (current >= total) {
+        output.write("\n")
+      }
+      return
+    }
+
+    console.log(line)
+  }
+
+  return {
+    tick(message) {
+      current += 1
+      render(message)
+    },
+    complete(message) {
+      current = total
+      render(message)
+    }
+  }
+}
+
+export async function withPromptSession(callback) {
+  const rl = readline.createInterface({ input, output })
+
+  try {
+    return await callback(rl)
+  } finally {
+    rl.close()
+  }
+}
+
+export async function promptText(rl, options) {
+  const { label, defaultValue = "", validate } = options
+
+  while (true) {
+    const suffix = defaultValue ? ` ${dim(`[${defaultValue}]`)}` : ""
+    const answer = (await rl.question(`${label}${suffix}: `)).trim()
+    const value = answer === "" ? defaultValue : answer
+
+    if (!validate) {
+      return value
+    }
+
+    const result = validate(value)
+    if (result === true) {
+      return value
+    }
+
+    console.log(dim(typeof result === "string" ? result : "Invalid value"))
+  }
+}
+
+export async function promptConfirm(rl, options) {
+  const { label, defaultValue = true } = options
+  const hint = defaultValue ? "[Y/n]" : "[y/N]"
+
+  while (true) {
+    const answer = (await rl.question(`${label} ${dim(hint)}: `)).trim().toLowerCase()
+
+    if (answer === "") {
+      return defaultValue
+    }
+
+    if (answer === "y" || answer === "yes") {
+      return true
+    }
+
+    if (answer === "n" || answer === "no") {
+      return false
+    }
+  }
+}
+
+export async function promptSelect(rl, options) {
+  const { label, choices, defaultValue } = options
+
+  printSection(label)
+  for (let index = 0; index < choices.length; index += 1) {
+    const choice = choices[index]
+    const marker = `${index + 1}.`
+    const recommended = choice.value === defaultValue ? ` ${dim("(recommended)")}` : ""
+
+    console.log(`  ${marker} ${choice.label}${recommended}`)
+    if (choice.description) {
+      console.log(`     ${dim(choice.description)}`)
+    }
+  }
+
+  const fallbackIndex = Math.max(
+    0,
+    choices.findIndex((choice) => choice.value === defaultValue)
+  )
+
+  while (true) {
+    const answer = (await rl.question(`Choose ${dim(`[${fallbackIndex + 1}]`)}: `)).trim()
+    const selectedIndex = answer === "" ? fallbackIndex : Number.parseInt(answer, 10) - 1
+
+    if (choices[selectedIndex]) {
+      console.log("")
+      return choices[selectedIndex].value
+    }
+
+    console.log(dim("Select one of the listed options."))
+  }
+}

package/templates/basic/README.md

@@ -0,0 +1,15 @@
+# Reset App
+
+Generated with `reset-framework-cli`.
+
+## Commands
+
+- `reset-framework-cli dev`
+- `reset-framework-cli build`
+- `reset-framework-cli package`
+
+## Project files
+
+- `reset.config.json`: desktop app metadata and runtime config
+- `frontend/` or project root: web frontend source, depending on the selected layout
+- `.reset/`: generated build output and native runtime cache