@nextsparkjs/core 0.1.0-beta.189 → 0.1.0-beta.190

package/scripts/build/safe-fs.mjs

@@ -0,0 +1,279 @@
+/**
+ * The one way the generator writes, creates directories, renames and removes:
+ * the registry build and the rest of scripts/build, and `nextspark sync:app`,
+ * which loads this module from the core installed in the project. No other file
+ * of the generator calls fs to change anything; a test fails when one does.
+ *
+ * Each call is bound to a root, the directory it may change things under: the
+ * project, or, for the themes of the monorepo, the monorepo. Before it touches
+ * anything the call looks at the path it was given, from the root down, and
+ * refuses - throwing an error with the code UNSAFE_WRITE and writing nothing -
+ * when the path is outside the root, when something along it inside the root is
+ * a symlink, the path itself included, when a part of it can't be looked at,
+ * when what exists of it resolves outside the root, or when the file it would
+ * write into has other hard links, which writing it would change too. What goes
+ * through a symlink lands wherever the symlink points; what a hard link shares
+ * is written wherever the other names are.
+ *
+ * What the check looks at is what is on disk when the call runs. A file is
+ * opened without following a symlink put in its place after the check; a
+ * directory along the path replaced by one in between is not caught.
+ *
+ * @module core/scripts/build/safe-fs
+ */
+
+import {
+  closeSync,
+  constants,
+  fchmodSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readSync,
+  realpathSync,
+  renameSync,
+  rmdirSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+  writeSync,
+} from 'fs'
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'path'
+
+/** The code of the error a refused call throws. */
+export const UNSAFE_WRITE = 'UNSAFE_WRITE'
+
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0
+
+/** The open flags of the writeFile flags the generator uses, none of them following a symlink. */
+const WRITE_FLAGS = {
+  w: constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | NO_FOLLOW,
+  wx: constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | NO_FOLLOW,
+}
+
+/** The size of the buffer copyFile reads and writes through: memory use stays at this regardless of file size. */
+export const COPY_BLOCK_SIZE = 1024 * 1024
+
+/** The copyFile mode bits safe-fs can honor without following the destination: no flag, or COPYFILE_EXCL. */
+const KNOWN_COPY_MODE = constants.COPYFILE_EXCL
+
+/**
+ * Whether `error` is a refusal of this module: nothing was written, and the
+ * caller must not carry on as if it had been, or read it as a missing file.
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export function isUnsafeWrite(error) {
+  return error instanceof Error && error.code === UNSAFE_WRITE
+}
+
+/** A path from `base` with forward slashes, as a refusal names it. */
+function fromBase(base, absolute) {
+  return relative(base, absolute).split(sep).join('/') || '.'
+}
+
+/** `path` with a separator at its end, for telling whether another path is under it. */
+function withSeparator(path) {
+  return path.endsWith(sep) ? path : `${path}${sep}`
+}
+
+function realpathOrNull(path) {
+  try {
+    return realpathSync(path)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Where `absolute` is looked at from: the root as given when it is under it, or
+ * else the shortest of its own leading directories that is the root under
+ * another spelling - through a symlink above the root, like /tmp on macOS -
+ * whatever comes after that one being looked at part by part; null when none is.
+ */
+function spelledRoot(absolute, rootPath, rootReal) {
+  if (absolute.startsWith(withSeparator(rootPath))) return rootPath
+  const leading = []
+  for (let path = dirname(absolute); ; path = dirname(path)) {
+    leading.unshift(path)
+    if (dirname(path) === path) break
+  }
+  for (const path of leading) {
+    try {
+      if (realpathSync(path) === rootReal) return path
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+/**
+ * What is wrong with changing `target` under `root`, or null when nothing is.
+ * A target spelled with another path to the root - through a symlink above it,
+ * like /tmp on macOS - is looked at from where that path reaches the root.
+ *
+ * @param {string} root - The directory the change may be made under
+ * @param {string} target - An absolute path, or one from the root
+ * @param {{ writesInto?: boolean, root?: boolean }} [options] - `writesInto` when an existing file at `target` is written
+ *   into; `root` when the root itself may be the target, as for creating a directory that is there already
+ * @returns {{ target: string, path: string, problem: string } | null} The target and the path the problem is at, both
+ *   from the root, and the problem
+ */
+export function unsafeWriteProblem(root, target, { writesInto = false, root: rootAllowed = false } = {}) {
+  const rootPath = resolve(root)
+  const absolute = resolve(rootPath, target)
+  let rootReal
+  try {
+    rootReal = realpathSync(rootPath)
+  } catch {
+    return { target: absolute, path: rootPath, problem: "can't be resolved" }
+  }
+  if (absolute === rootPath) {
+    return rootAllowed ? null : { target: '.', path: '.', problem: 'is the root itself, which is not changed' }
+  }
+  const base = spelledRoot(absolute, rootPath, rootReal)
+  if (base === null && rootAllowed && realpathOrNull(absolute) === rootReal) return null
+  const along = base === null ? null : relative(base, absolute)
+  if (along === null || along === '' || isAbsolute(along) || along === '..' || along.startsWith(`..${sep}`)) {
+    return { target: absolute, path: absolute, problem: `is outside ${rootPath}` }
+  }
+  const shownTarget = fromBase(base, absolute)
+
+  let deepest = base
+  let current = base
+  const parts = along.split(sep)
+  for (let depth = 0; depth < parts.length; depth++) {
+    current = join(current, parts[depth])
+    let stat
+    try {
+      stat = lstatSync(current)
+    } catch (error) {
+      // Nothing is there yet, or a file stands where a directory goes and the call itself fails
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') break
+      return { target: shownTarget, path: fromBase(base, current), problem: "can't be looked at" }
+    }
+    if (stat.isSymbolicLink()) {
+      return { target: shownTarget, path: fromBase(base, current), problem: 'is a symlink' }
+    }
+    deepest = current
+    if (depth === parts.length - 1) {
+      if (writesInto && stat.isFile() && stat.nlink > 1) {
+        return { target: shownTarget, path: shownTarget, problem: 'has other hard links' }
+      }
+    } else if (!stat.isDirectory()) {
+      break
+    }
+  }
+
+  let deepestReal
+  try {
+    deepestReal = realpathSync(deepest)
+  } catch {
+    return { target: shownTarget, path: fromBase(base, deepest), problem: "can't be resolved" }
+  }
+  if (deepestReal !== rootReal && !deepestReal.startsWith(withSeparator(rootReal))) {
+    return { target: shownTarget, path: fromBase(base, deepest), problem: `resolves outside ${rootReal}` }
+  }
+  return null
+}
+
+/** The error a refused call throws. */
+function refusal(operation, root, { target, path, problem }) {
+  const error = new Error(
+    `Refused to ${operation} ${target}: ${path} ${problem}, and nothing was written. ` +
+    'What is written or removed through a symlink, a hard link or a path out of the project lands outside it: ' +
+    'make each part of the path a file or directory of its own inside the project, and run the command again.'
+  )
+  return Object.assign(error, { code: UNSAFE_WRITE, root: resolve(root), target, path, problem })
+}
+
+/** `target` as an absolute path under `root`, once changing it is safe; throws the refusal otherwise. */
+function checked(operation, root, target, options) {
+  const problem = unsafeWriteProblem(root, target, options)
+  if (problem) throw refusal(operation, root, problem)
+  return resolve(resolve(root), target)
+}
+
+/** The flags a writeFile call opens with: the ones the generator uses, never following a symlink. */
+function writeOptions(options) {
+  const normalized = typeof options === 'string' ? { encoding: options } : { ...options }
+  const flag = normalized.flag ?? 'w'
+  if (!(flag in WRITE_FLAGS)) {
+    throw new Error(`safe-fs writes with the flags ${Object.keys(WRITE_FLAGS).join(' and ')}, not ${flag}`)
+  }
+  return { ...normalized, flag: WRITE_FLAGS[flag] }
+}
+
+/**
+ * The calls that change things under `root`, each refusing - with an error whose
+ * code is UNSAFE_WRITE, before touching anything - what `unsafeWriteProblem`
+ * finds wrong with its path. Paths are absolute, or from the root.
+ *
+ * @param {string} root - The directory these calls may change things under
+ */
+export function projectFiles(root) {
+  const writeFile = (path, data, options) => {
+    writeFileSync(checked('write', root, path, { writesInto: true }), data, writeOptions(options))
+  }
+  const mkdir = (path, options) => mkdirSync(checked('create', root, path, { root: true }), options)
+  const mkdtemp = prefix => {
+    checked('create a directory beside', root, prefix)
+    return mkdtempSync(resolve(resolve(root), prefix))
+  }
+  const copyFile = (source, destination, mode = 0) => {
+    if (mode & ~KNOWN_COPY_MODE) {
+      throw new Error(`safe-fs copies with COPYFILE_EXCL or no mode, not ${mode}`)
+    }
+    const target = checked('copy to', root, destination, { writesInto: true })
+    const sourceFd = openSync(source, constants.O_RDONLY)
+    try {
+      const sourceMode = fstatSync(sourceFd).mode
+      const flag = mode & constants.COPYFILE_EXCL ? WRITE_FLAGS.wx : WRITE_FLAGS.w
+      const destFd = openSync(target, flag, sourceMode & 0o777)
+      try {
+        const buffer = Buffer.allocUnsafe(COPY_BLOCK_SIZE)
+        for (;;) {
+          const bytesRead = readSync(sourceFd, buffer, 0, COPY_BLOCK_SIZE, null)
+          if (bytesRead === 0) break
+          writeSync(destFd, buffer, 0, bytesRead, null)
+        }
+        fchmodSync(destFd, sourceMode & 0o777)
+      } finally {
+        closeSync(destFd)
+      }
+    } finally {
+      closeSync(sourceFd)
+    }
+  }
+  const rm = (path, options) => rmSync(checked('remove', root, path), options)
+  const rmdir = path => rmdirSync(checked('remove', root, path))
+  const unlink = path => unlinkSync(checked('remove', root, path))
+  const rename = (from, to) => {
+    const source = checked('move', root, from)
+    renameSync(source, checked('move to', root, to))
+  }
+
+  return {
+    root: resolve(root),
+    writeFileSync: writeFile,
+    mkdirSync: mkdir,
+    mkdtempSync: mkdtemp,
+    copyFileSync: copyFile,
+    rmSync: rm,
+    rmdirSync: rmdir,
+    unlinkSync: unlink,
+    renameSync: rename,
+    writeFile: async (...args) => writeFile(...args),
+    mkdir: async (...args) => mkdir(...args),
+    mkdtemp: async (...args) => mkdtemp(...args),
+    copyFile: async (...args) => copyFile(...args),
+    rm: async (...args) => rm(...args),
+    rmdir: async (...args) => rmdir(...args),
+    unlink: async (...args) => unlink(...args),
+    rename: async (...args) => rename(...args),
+  }
+}

package/scripts/build/templates-plan.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * What the registry build would change in a project's app/(templates), worked
+ * out without writing anything. `nextspark sync:app` runs it to name those
+ * changes in --dry-run, and to count them before asking for confirmation.
+ *
+ * The project comes from NEXTSPARK_PROJECT_ROOT, as for registry.mjs. Stdin
+ * carries a JSON object of files under app/, by path from the project root, to
+ * read as having that content (null: removed) instead of what is on disk: what
+ * the sync about to run leaves there, since the build copies app/ layouts into
+ * the tree. The result is printed on a line of its own, after
+ * `nextspark-templates-plan:`, as { create, replace, remove } with paths from
+ * the project root.
+ */
+
+// First, so what any module prints as it loads is escaped too
+import '../utils/console-guard.mjs'
+
+import { getConfig } from './registry/config.mjs'
+import { discoverTemplates } from './registry/discovery/templates.mjs'
+import { planMissingPages } from './registry/post-build/page-generator.mjs'
+import { jsonLine, messageLines } from '../utils/index.mjs'
+
+const RESULT_MARKER = 'nextspark-templates-plan:'
+
+async function readAppFiles() {
+  if (process.stdin.isTTY) return new Map()
+
+  let input = ''
+  for await (const chunk of process.stdin) input += chunk
+  return new Map(Object.entries(input.trim() ? JSON.parse(input) : {}))
+}
+
+try {
+  const appFiles = await readAppFiles()
+  const config = getConfig()
+  const templates = await discoverTemplates(config)
+  const changes = await planMissingPages(templates, config, appFiles)
+  console.log(`${RESULT_MARKER}${jsonLine(changes)}`)
+} catch (error) {
+  for (const line of messageLines(error)) console.error(line)
+  process.exit(1)
+}

package/scripts/build/theme.mjs

@@ -11,11 +11,13 @@
  *   node scripts/build-theme.mjs --watch  # Build and watch for changes
  */
 
-import fs from 'fs'
+import { existsSync, readdirSync, readFileSync, statSync, watch } from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import dotenv from 'dotenv'
 import { getConfig } from './registry/config.mjs'
+import { isUnsafeWrite, projectFiles } from './safe-fs.mjs'
+import { rewriteBelowGeneratedTag } from '../utils/generated-tag.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -70,8 +72,8 @@ ${expectedImport}
 `
 
   // Check if file exists and has correct import
-  if (fs.existsSync(appGlobalsCssPath)) {
-    const currentContent = fs.readFileSync(appGlobalsCssPath, 'utf8')
+  if (existsSync(appGlobalsCssPath)) {
+    const currentContent = readFileSync(appGlobalsCssPath, 'utf8')
 
     // Extract current import (handle various formats)
     const importMatch = currentContent.match(/@import\s+["']([^"']+)["'];?/)
@@ -84,20 +86,21 @@ ${expectedImport}
         return false // Already correct, no update needed
       }
 
-      // Update only the import line, preserving any custom comments
-      const updatedContent = currentContent.replace(
-        /@import\s+["'][^"']+["'];?/,
-        expectedImport
+      // Update only the import line, preserving any custom comments. A generated
+      // tag sync:app put on the file keeps telling the truth: rehashed when the
+      // file still matched it, left as it was when the project had changed it.
+      const updatedContent = rewriteBelowGeneratedTag(currentContent, body =>
+        body.replace(/@import\s+["'][^"']+["'];?/, expectedImport)
       )
 
-      fs.writeFileSync(appGlobalsCssPath, updatedContent)
+      projectFiles(config.projectRoot).writeFileSync(appGlobalsCssPath, updatedContent)
       console.log(`   🔄 Updated app/globals.css import: ${relativePath}`)
       return true
     }
   }
 
   // File doesn't exist or has no import - write full template
-  fs.writeFileSync(appGlobalsCssPath, template)
+  projectFiles(config.projectRoot).writeFileSync(appGlobalsCssPath, template)
   console.log(`   ✅ Created app/globals.css with import: ${relativePath}`)
   return true
 }
@@ -106,16 +109,16 @@ ${expectedImport}
  * Recursively copy directory contents
  */
 function copyRecursive(src, dest) {
-  const stats = fs.statSync(src)
+  const stats = statSync(src)
 
   if (stats.isDirectory()) {
     // Create directory if it doesn't exist
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true })
+    if (!existsSync(dest)) {
+      projectFiles(rootDir).mkdirSync(dest, { recursive: true })
     }
 
     // Read directory contents
-    const entries = fs.readdirSync(src, { withFileTypes: true })
+    const entries = readdirSync(src, { withFileTypes: true })
 
     for (const entry of entries) {
       const srcPath = path.join(src, entry.name)
@@ -124,11 +127,11 @@ function copyRecursive(src, dest) {
       if (entry.isDirectory()) {
         copyRecursive(srcPath, destPath)
       } else {
-        fs.copyFileSync(srcPath, destPath)
+        projectFiles(rootDir).copyFileSync(srcPath, destPath)
       }
     }
   } else {
-    fs.copyFileSync(src, dest)
+    projectFiles(rootDir).copyFileSync(src, dest)
   }
 }
 
@@ -138,11 +141,11 @@ function copyRecursive(src, dest) {
 function countFiles(dir) {
   let count = 0
 
-  if (!fs.existsSync(dir)) {
+  if (!existsSync(dir)) {
     return 0
   }
 
-  const entries = fs.readdirSync(dir, { withFileTypes: true })
+  const entries = readdirSync(dir, { withFileTypes: true })
 
   for (const entry of entries) {
     if (entry.isDirectory()) {
@@ -163,32 +166,32 @@ function copyBlockThumbnails(themePath, activeTheme) {
   const blocksPath = path.join(themePath, 'blocks')
   const publicBlocksPath = path.join(rootDir, 'public', 'theme', 'blocks')
 
-  if (!fs.existsSync(blocksPath)) {
+  if (!existsSync(blocksPath)) {
     return 0
   }
 
   // Ensure public/theme/blocks directory exists
-  if (!fs.existsSync(publicBlocksPath)) {
-    fs.mkdirSync(publicBlocksPath, { recursive: true })
+  if (!existsSync(publicBlocksPath)) {
+    projectFiles(rootDir).mkdirSync(publicBlocksPath, { recursive: true })
   }
 
   let copiedCount = 0
-  const blockDirs = fs.readdirSync(blocksPath, { withFileTypes: true })
+  const blockDirs = readdirSync(blocksPath, { withFileTypes: true })
     .filter(dirent => dirent.isDirectory())
 
   for (const blockDir of blockDirs) {
     const thumbnailSrc = path.join(blocksPath, blockDir.name, 'thumbnail.png')
 
-    if (fs.existsSync(thumbnailSrc)) {
+    if (existsSync(thumbnailSrc)) {
       const thumbnailDestDir = path.join(publicBlocksPath, blockDir.name)
       const thumbnailDest = path.join(thumbnailDestDir, 'thumbnail.png')
 
       // Create destination directory if needed
-      if (!fs.existsSync(thumbnailDestDir)) {
-        fs.mkdirSync(thumbnailDestDir, { recursive: true })
+      if (!existsSync(thumbnailDestDir)) {
+        projectFiles(rootDir).mkdirSync(thumbnailDestDir, { recursive: true })
       }
 
-      fs.copyFileSync(thumbnailSrc, thumbnailDest)
+      projectFiles(rootDir).copyFileSync(thumbnailSrc, thumbnailDest)
       copiedCount++
     }
   }
@@ -205,11 +208,11 @@ function copyThemePublicAssets(themePath, activeTheme) {
   const publicThemePath = path.join(rootDir, 'public', 'theme')
 
   // Ensure public/theme directory exists
-  if (!fs.existsSync(publicThemePath)) {
-    fs.mkdirSync(publicThemePath, { recursive: true })
+  if (!existsSync(publicThemePath)) {
+    projectFiles(rootDir).mkdirSync(publicThemePath, { recursive: true })
   }
 
-  if (!fs.existsSync(themePublicPath)) {
+  if (!existsSync(themePublicPath)) {
     console.log(`   ℹ️  No public assets directory found for theme: ${activeTheme}`)
     return
   }
@@ -225,6 +228,7 @@ function copyThemePublicAssets(themePath, activeTheme) {
       console.log(`   ✅ Copied ${fileCount} asset(s) to public/theme/`)
     }
   } catch (error) {
+    if (isUnsafeWrite(error)) throw error
     console.error(`   ❌ Failed to copy public assets:`, error)
   }
 }
@@ -279,8 +283,8 @@ export async function buildTheme(projectRoot = null) {
   const themePath = path.join(config.contentsDir, 'themes', activeTheme)
 
   // Ensure output directory exists
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true })
+  if (!existsSync(outputDir)) {
+    projectFiles(config.projectRoot).mkdirSync(outputDir, { recursive: true })
   }
 
   // Sync app/globals.css to import from the active theme
@@ -288,7 +292,7 @@ export async function buildTheme(projectRoot = null) {
   syncAppGlobalsCss(config, activeTheme)
 
   // Copy theme public assets (for all themes, including default)
-  if (fs.existsSync(themePath)) {
+  if (existsSync(themePath)) {
     copyThemePublicAssets(themePath, activeTheme)
 
     // Copy block thumbnails to public/theme/blocks/
@@ -299,22 +303,22 @@ export async function buildTheme(projectRoot = null) {
   }
 
   // Build theme (including default - all themes load their own styles)
-  if (!fs.existsSync(themePath)) {
+  if (!existsSync(themePath)) {
     console.error(`❌ Theme directory not found: ${themePath}`)
     console.log('📁 Available themes:')
 
     const themesDir = path.join(rootDir, 'contents', 'themes')
-    const availableThemes = fs.readdirSync(themesDir)
+    const availableThemes = readdirSync(themesDir)
       .filter(item => {
         const itemPath = path.join(themesDir, item)
-        return fs.statSync(itemPath).isDirectory() && item !== 'node_modules'
+        return statSync(itemPath).isDirectory() && item !== 'node_modules'
       })
 
     availableThemes.forEach(theme => console.log(`   - ${theme}`))
 
     // Fallback to empty (core styles only)
     console.log('🔄 Falling back to core styles only')
-    fs.writeFileSync(outputPath, `/* Fallback: Theme '${activeTheme}' not found, using core styles */\n`)
+    projectFiles(config.projectRoot).writeFileSync(outputPath, `/* Fallback: Theme '${activeTheme}' not found, using core styles */\n`)
     return
   }
 
@@ -328,8 +332,8 @@ export async function buildTheme(projectRoot = null) {
     let globalCSS = ''
     let componentCSS = ''
 
-    if (fs.existsSync(globalStylesPath)) {
-      globalCSS = fs.readFileSync(globalStylesPath, 'utf8')
+    if (existsSync(globalStylesPath)) {
+      globalCSS = readFileSync(globalStylesPath, 'utf8')
       console.log(`   ✅ Loaded globals.css (${globalCSS.length} chars)`)
 
       // Validate that theme has all required sections
@@ -338,8 +342,8 @@ export async function buildTheme(projectRoot = null) {
       console.warn(`   ⚠️  globals.css not found: ${globalStylesPath}`)
     }
 
-    if (fs.existsSync(componentStylesPath)) {
-      componentCSS = fs.readFileSync(componentStylesPath, 'utf8')
+    if (existsSync(componentStylesPath)) {
+      componentCSS = readFileSync(componentStylesPath, 'utf8')
       console.log(`   ✅ Loaded components.css (${componentCSS.length} chars)`)
     } else {
       console.warn(`   ⚠️  components.css not found: ${componentStylesPath}`)
@@ -362,7 +366,7 @@ ${componentCSS}
 `
 
     // Write final CSS to .next directory (for build cache)
-    fs.writeFileSync(outputPath, finalCSS)
+    projectFiles(config.projectRoot).writeFileSync(outputPath, finalCSS)
 
     console.log(`✅ Theme built successfully!`)
     console.log(`📄 Output: ${outputPath} (${finalCSS.length} chars)`)
@@ -379,7 +383,7 @@ ${componentCSS}
  * Falling back to core styles only.
  */
 `
-    fs.writeFileSync(outputPath, errorCSS)
+    projectFiles(config.projectRoot).writeFileSync(outputPath, errorCSS)
 
     throw error
   }
@@ -399,7 +403,7 @@ async function watchTheme() {
   let debounceTimer = null
 
   try {
-    const watcher = fs.watch(stylesPath, { recursive: true }, (eventType, filename) => {
+    const watcher = watch(stylesPath, { recursive: true }, (eventType, filename) => {
       if (filename && (filename.endsWith('.css'))) {
         clearTimeout(debounceTimer)
         debounceTimer = setTimeout(async () => {

package/scripts/build/update-tsconfig.mjs

@@ -15,10 +15,11 @@
  * Usage: node core/scripts/build/update-tsconfig.mjs
  */
 
-import fs from 'fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import dotenv from 'dotenv'
+import { projectFiles } from './safe-fs.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -44,14 +45,14 @@ const PLUGINS_DIR = path.join(ROOT_DIR, 'contents/plugins')
  * Get all theme directories
  */
 function getAllThemes() {
-  if (!fs.existsSync(THEMES_DIR)) {
+  if (!existsSync(THEMES_DIR)) {
     return []
   }
 
-  return fs.readdirSync(THEMES_DIR)
+  return readdirSync(THEMES_DIR)
     .filter(item => {
       const themePath = path.join(THEMES_DIR, item)
-      return fs.statSync(themePath).isDirectory()
+      return statSync(themePath).isDirectory()
     })
 }
 
@@ -59,14 +60,14 @@ function getAllThemes() {
  * Get all plugin directories
  */
 function getAllPlugins() {
-  if (!fs.existsSync(PLUGINS_DIR)) {
+  if (!existsSync(PLUGINS_DIR)) {
     return []
   }
 
-  return fs.readdirSync(PLUGINS_DIR)
+  return readdirSync(PLUGINS_DIR)
     .filter(item => {
       const pluginPath = path.join(PLUGINS_DIR, item)
-      return fs.statSync(pluginPath).isDirectory()
+      return statSync(pluginPath).isDirectory()
     })
 }
 
@@ -76,20 +77,20 @@ function getAllPlugins() {
 function getActivePlugins(activeTheme) {
   const themeConfigPath = path.join(THEMES_DIR, activeTheme, 'theme.config.ts')
 
-  if (!fs.existsSync(themeConfigPath)) {
+  if (!existsSync(themeConfigPath)) {
     // Try .js extension
     const jsConfigPath = path.join(THEMES_DIR, activeTheme, 'theme.config.js')
-    if (!fs.existsSync(jsConfigPath)) {
+    if (!existsSync(jsConfigPath)) {
       return []
     }
   }
 
   try {
-    const configPath = fs.existsSync(path.join(THEMES_DIR, activeTheme, 'theme.config.ts'))
+    const configPath = existsSync(path.join(THEMES_DIR, activeTheme, 'theme.config.ts'))
       ? path.join(THEMES_DIR, activeTheme, 'theme.config.ts')
       : path.join(THEMES_DIR, activeTheme, 'theme.config.js')
 
-    const configContent = fs.readFileSync(configPath, 'utf8')
+    const configContent = readFileSync(configPath, 'utf8')
 
     // Match plugins array: plugins: ['plugin1', 'plugin2']
     const pluginsMatch = configContent.match(/plugins:\s*\[(.*?)\]/s)
@@ -119,14 +120,14 @@ function generateTsConfig() {
   const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME
 
   // Check if base template exists
-  if (!fs.existsSync(TSCONFIG_BASE_PATH)) {
+  if (!existsSync(TSCONFIG_BASE_PATH)) {
     console.error('❌ tsconfig.base.json not found!')
     console.error('   Please ensure tsconfig.base.json exists in the project root.')
     process.exit(1)
   }
 
   // Read base template
-  const baseConfig = JSON.parse(fs.readFileSync(TSCONFIG_BASE_PATH, 'utf8'))
+  const baseConfig = JSON.parse(readFileSync(TSCONFIG_BASE_PATH, 'utf8'))
 
   // In NPM mode, add @nextspark/* aliases for registry and core resolution
   if (isNpmPackage) {
@@ -178,7 +179,7 @@ function generateTsConfig() {
     console.warn('⚠️  NEXT_PUBLIC_ACTIVE_THEME not set')
     console.warn('   Using base excludes only (all themes/plugins will be checked)')
     baseConfig.exclude = baseExcludes
-    fs.writeFileSync(TSCONFIG_PATH, JSON.stringify(baseConfig, null, 2) + '\n', 'utf8')
+    projectFiles(ROOT_DIR).writeFileSync(TSCONFIG_PATH, JSON.stringify(baseConfig, null, 2) + '\n', 'utf8')
     console.log('📝 Generated tsconfig.json (no active theme)')
     return
   }
@@ -200,7 +201,7 @@ function generateTsConfig() {
   baseConfig.exclude = [...baseExcludes, ...themeExcludes, ...pluginExcludes]
 
   // Write generated tsconfig
-  fs.writeFileSync(TSCONFIG_PATH, JSON.stringify(baseConfig, null, 2) + '\n', 'utf8')
+  projectFiles(ROOT_DIR).writeFileSync(TSCONFIG_PATH, JSON.stringify(baseConfig, null, 2) + '\n', 'utf8')
 
   console.log('📝 Generated tsconfig.json')
   console.log(`   Active theme: ${activeTheme}`)