rootless-config 1.7.4 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootless-config",
-  "version": "1.7.4",
+  "version": "1.8.1",
   "description": "Store project config files outside the project root, auto-deploy them where tools expect them.",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "main": "./src/index.js",
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./serve": "./src/serve/index.js"
   },
   "files": [
     "bin",

package/src/cli/commands/migrate.js

@@ -5,7 +5,7 @@ import { readdir, unlink } from 'node:fs/promises'
 import { createLogger } from '../../utils/logger.js'
 import { fileExists, ensureDir, atomicWrite, copyFile, readJsonFile } from '../../utils/fsUtils.js'
 import { confirm } from '../../utils/prompt.js'
-import { patchPackageScripts, isPatchable, NEVER_MIGRATE } from '../../core/scriptPatcher.js'
+import { patchPackageScripts, isPatchable, NEVER_MIGRATE, patchServerScript } from '../../core/scriptPatcher.js'
 
 // Files that are OS/editor/VCS noise — never migrate, never touch
 const SYSTEM_FILES = new Set([
@@ -92,6 +92,17 @@ export default {
       const dest = path.join(destDir, name)
 
       if (isCleanMode) {
+        // For PS1 server scripts: patch $root before writing to .root/assets/
+        if (name.endsWith('.ps1')) {
+          const raw = await (await import('node:fs/promises')).readFile(src, 'utf8')
+          const patched = patchServerScript(raw)
+          if (patched) {
+            await atomicWrite(dest, patched)
+            await unlink(src)
+            logger.success(`Moved+patched .root/${destSubdir}/${name} (server root → project root)`)
+            continue
+          }
+        }
         // Binary-safe stream copy — works for .png, .js, .css, etc.
         await copyFile(src, dest)
         await unlink(src)

package/src/core/scriptPatcher.js

@@ -459,6 +459,74 @@ async function patchPackageScripts(projectRoot, configsDir, logger) {
   return changed
 }
 
+/**
+ * Patches a PowerShell HTTP server script (.server.ps1 style) so it works
+ * correctly after being moved to .root/assets/.
+ *
+ * The script originally uses $PSScriptRoot as web root. After migration,
+ * $PSScriptRoot = .root/assets/ — so subdirectories left in the project root
+ * (viewer/, agreement/, etc.) are invisible to it.
+ *
+ * This patch:
+ *  1. Sets $root to the project root (2 dirs up from $PSScriptRoot)
+ *  2. Keeps $assetsRoot pointing to .root/assets/ for fallback
+ *  3. After path resolution, falls back to $assetsRoot when file not found in $root
+ *  4. Fixes the 404 page lookup to also check $assetsRoot
+ *
+ * Returns patched content, or null if the file doesn't look like a server script.
+ */
+function patchServerScript(content) {
+  // Only patch scripts that use $PSScriptRoot as web root
+  if (!content.includes('$PSScriptRoot') || !content.includes('$root')) return null
+
+  let out = content
+
+  // 1. Redefine $root → project root (2 levels up), keep $assetsRoot for fallback
+  out = out.replace(
+    /\$root(\s*)=(\s*)\$PSScriptRoot\.TrimEnd\('\\\\?'\)\s*\+\s*'\\\\'?/,
+    `$assetsRoot$1=$2$PSScriptRoot.TrimEnd('\\') + '\\'
+$root$1=$2(Get-Item "$PSScriptRoot\\..\\..").FullName.TrimEnd('\\') + '\\'`
+  )
+
+  // If the above didn't match (different whitespace/quoting), try simpler form
+  if (out === content) {
+    const marker = `$root           = $PSScriptRoot.TrimEnd('\\') + '\\'`
+    if (content.includes(marker)) {
+      out = out.replace(
+        marker,
+        `$assetsRoot     = $PSScriptRoot.TrimEnd('\\') + '\\'
+$root           = (Get-Item "$PSScriptRoot\\..\\..").FullName.TrimEnd('\\') + '\\'`
+      )
+    }
+  }
+
+  // 2. Add rootless fallback after $filePath = $resolved
+  const filePathLine = '            $filePath = $resolved'
+  if (out.includes(filePathLine)) {
+    out = out.replace(
+      filePathLine,
+      filePathLine + `
+            # rootless: fallback to .root/assets/ when file not found in project root
+            if ($relPath -ne '' -and -not (Test-Path $filePath)) {
+                $assetsCandidate = [System.IO.Path]::GetFullPath((Join-Path $assetsRoot $relPath))
+                if (Test-Path $assetsCandidate) { $filePath = $assetsCandidate }
+            }`
+    )
+  }
+
+  // 3. Fix 404 page lookup to also check $assetsRoot
+  const notFoundLine = '                    $candidate = Join-Path $root $filename'
+  if (out.includes(notFoundLine)) {
+    out = out.replace(
+      notFoundLine,
+      notFoundLine + `
+                    if (-not (Test-Path $candidate -PathType Leaf)) { $candidate = Join-Path $assetsRoot $filename }`
+    )
+  }
+
+  return out === content ? null : out
+}
+
 /**
  * Add "prepare": "rootless prepare --yes" to project's package.json.
  */
@@ -492,5 +560,6 @@ export {
   NEVER_MIGRATE,
   ROOT_REQUIRED_PATTERNS,
   WEB_ASSET_PATTERNS,
+  patchServerScript,
 }
 

package/src/index.js

@@ -5,6 +5,7 @@ import { createWatcher } from './watch/watcher.js'
 import { createDirtySet } from './watch/dirtySet.js'
 import { runIncrementalRegeneration } from './watch/incrementalRegeneration.js'
 import { resolveContainerPath } from './core/pathResolver.js'
+import { resolveStaticFile, getServeDirs } from './serve/index.js'
 
 async function prepare(options = {}) {
   return preparePipeline(options)
@@ -36,4 +37,4 @@ async function watch(options = {}) {
   }
 }
 
-export { prepare, watch, clean }
+export { prepare, watch, clean, resolveStaticFile, getServeDirs }

package/src/serve/index.js

@@ -0,0 +1,74 @@
+/*-------- Public serve API — for use in Tandem Sites and other dev servers --------*/
+
+import path from 'node:path'
+import { stat, readFile } from 'node:fs/promises'
+
+/**
+ * Resolves a URL path to a real file on disk.
+ *
+ * Search order (first match wins):
+ *   [1] projectRoot          — real files/folders in project root
+ *   [2] .root/assets/        — files migrated to rootless container
+ *   [3] .root/env/           — .env files in rootless container
+ *
+ * Also tries index.html / index.htm for directory requests.
+ *
+ * @param {string} requestPath  — e.g. '/viewer/app/code/app.js' or '/'
+ * @param {string} projectRoot  — absolute path to the project root
+ * @returns {Promise<string|null>} absolute path to the file, or null if not found
+ */
+async function resolveStaticFile(requestPath, projectRoot) {
+  const containerPath = path.join(projectRoot, '.root')
+  const assetsDir     = path.join(containerPath, 'assets')
+  const envDir        = path.join(containerPath, 'env')
+  const searchDirs    = [projectRoot, assetsDir, envDir]
+
+  const rel = decodeURIComponent(requestPath).replace(/^\//, '') || ''
+
+  for (const dir of searchDirs) {
+    // Block access to .root internals when searching from projectRoot
+    if (dir === projectRoot && rel.startsWith('.root')) continue
+
+    const candidates = rel === ''
+      ? [
+          path.join(dir, 'index.html'),
+          path.join(dir, 'index.htm'),
+        ]
+      : [
+          path.join(dir, rel),
+          path.join(dir, rel, 'index.html'),
+          path.join(dir, rel, 'index.htm'),
+        ]
+
+    for (const candidate of candidates) {
+      try {
+        if ((await stat(candidate)).isFile()) return candidate
+      } catch {
+        // not found, try next
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Returns the ordered list of directories that rootless serves from.
+ * Useful for configuring a static server manually.
+ *
+ * @param {string} projectRoot
+ * @returns {{ projectRoot: string, assetsDir: string, envDir: string, searchDirs: string[] }}
+ */
+function getServeDirs(projectRoot) {
+  const containerPath = path.join(projectRoot, '.root')
+  const assetsDir     = path.join(containerPath, 'assets')
+  const envDir        = path.join(containerPath, 'env')
+  return {
+    projectRoot,
+    assetsDir,
+    envDir,
+    searchDirs: [projectRoot, assetsDir, envDir],
+  }
+}
+
+export { resolveStaticFile, getServeDirs }