rootless-config 1.8.2 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rootless-config",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "Store project config files outside the project root, auto-deploy them where tools expect them.",
   "type": "module",
   "bin": {

package/src/cli/commands/repatch.js

@@ -0,0 +1,138 @@
+/*-------- rootless repatch — re-apply server script patches to files in .root/ --------*/
+
+import path from 'node:path'
+import { readdir, readFile, writeFile } from 'node:fs/promises'
+import { createLogger } from '../../utils/logger.js'
+import { fileExists } from '../../utils/fsUtils.js'
+import { patchServerScript } from '../../core/scriptPatcher.js'
+
+/**
+ * Strip any previous rootless patches from a PS1 file so that patchServerScript
+ * can be applied fresh.
+ *
+ * Handles two cases:
+ *  - New-style: content wrapped in `# <rootless>` … `# </rootless>` markers
+ *  - Old-style: $assetsRoot + $root = (Get-Item ...) two-liner (pre-1.9.0)
+ */
+function stripRootlessPatches(content) {
+  // New-style: remove the whole # <rootless> … # </rootless> block and restore
+  // the minimal $root = $PSScriptRoot line so patchServerScript can re-match it.
+  let out = content.replace(
+    /^#[ \t]*<rootless>[\s\S]*?^#[ \t]*<\/rootless>\n?/m,
+    "$root = $PSScriptRoot.TrimEnd('\\\\') + '\\\\'\n"
+  )
+
+  // Old-style (v1.8.x and earlier): $assetsRoot line + $root = (Get-Item ...) line
+  // Replace the pair with a minimal $root = $PSScriptRoot assignment so patchServerScript
+  // can re-match it and apply the new runtime-detection block.
+  out = out.replace(
+    /^[ \t]*\$assetsRoot[ \t]*=[ \t]*\$PSScriptRoot[^\n]*\n[ \t]*\$root[ \t]*=[ \t]*\(Get-Item[^\n]*/m,
+    "$root = $PSScriptRoot.TrimEnd('\\\\') + '\\\\'"
+  )
+
+  // Also strip inline rootless comments added by old patch (file fallback, null guard, 404 fallback)
+  // — these are harder to reverse generically, so we leave them in place. The new patch adds its
+  //   own version above, and the old ones become inert (they still work, just redundant).
+  return out
+}
+
+/**
+ * Re-patch a single .ps1 file. Returns 'patched' | 'already-current' | 'skipped'.
+ */
+async function repatchPs1(filePath) {
+  const content = await readFile(filePath, 'utf8')
+
+  // Already has new-style patch — nothing to do
+  if (content.includes('# <rootless>')) return 'already-current'
+
+  // Doesn't look like a server script at all
+  if (!content.includes('$PSScriptRoot') || !content.includes('$root')) return 'skipped'
+
+  const stripped = stripRootlessPatches(content)
+  const patched  = patchServerScript(stripped)
+  if (!patched) return 'skipped'
+
+  await writeFile(filePath, patched, 'utf8')
+  return 'patched'
+}
+
+/**
+ * Re-patch a .cmd / .bat launcher so it uses %~dp0-relative path to the .ps1.
+ * Returns true if the file was changed.
+ */
+async function repatchCmd(filePath) {
+  const content = await readFile(filePath, 'utf8')
+  const patched = content.replace(
+    /(-File\s+)(?!")([^\s"]+\.ps1)/gi,
+    (_, flag, ps1) => `${flag}"%~dp0${ps1}"`
+  )
+  if (patched === content) return false
+  await writeFile(filePath, patched, 'utf8')
+  return true
+}
+
+export default {
+  name: 'repatch',
+  description: 'Re-apply server script patches to .ps1/.cmd files in .root/ (use after upgrading rootless)',
+
+  async handler(args) {
+    const logger = createLogger({ verbose: args.verbose ?? false })
+    const projectRoot = args.cwd ? path.resolve(args.cwd) : process.cwd()
+    const containerPath = path.join(projectRoot, '.root')
+
+    if (!(await fileExists(containerPath))) {
+      logger.warn('No .root/ container found. Run: rootless setup')
+      return
+    }
+
+    logger.info('Scanning .root/ for patchable scripts…')
+
+    let ps1Patched = 0
+    let ps1Current = 0
+    let ps1Skipped = 0
+    let cmdPatched = 0
+
+    for (const sub of ['assets', 'configs', 'env']) {
+      const dir = path.join(containerPath, sub)
+      if (!(await fileExists(dir))) continue
+
+      const entries = await readdir(dir, { withFileTypes: true })
+      for (const e of entries) {
+        if (!e.isFile()) continue
+        const full = path.join(dir, e.name)
+
+        if (e.name.endsWith('.ps1')) {
+          const result = await repatchPs1(full)
+          if (result === 'patched') {
+            ps1Patched++
+            logger.success(`Repatched: .root/${sub}/${e.name}`)
+          } else if (result === 'already-current') {
+            ps1Current++
+            logger.debug(`Up-to-date: .root/${sub}/${e.name}`)
+          } else {
+            ps1Skipped++
+            logger.debug(`Skipped (not a server script): .root/${sub}/${e.name}`)
+          }
+        }
+
+        if (e.name.endsWith('.cmd') || e.name.endsWith('.bat')) {
+          const changed = await repatchCmd(full)
+          if (changed) {
+            cmdPatched++
+            logger.success(`Repatched: .root/${sub}/${e.name}`)
+          }
+        }
+      }
+    }
+
+    logger.info('')
+    if (ps1Patched + cmdPatched === 0 && ps1Current === 0) {
+      logger.info('Nothing to patch.')
+    } else {
+      if (ps1Patched)  logger.success(`${ps1Patched} .ps1 file(s) repatched`)
+      if (cmdPatched)  logger.success(`${cmdPatched} .cmd/.bat file(s) repatched`)
+      if (ps1Current)  logger.info(`${ps1Current} .ps1 file(s) already up-to-date`)
+      if (ps1Skipped)  logger.debug(`${ps1Skipped} .ps1 file(s) skipped (not server scripts)`)
+    }
+  },
+}

package/src/cli/commands/setup.js

@@ -87,14 +87,13 @@ export default {
     logger.info('  .root/assets/  — web assets, HTML, images, scripts')
     logger.info('  .root/configs/ — tool configs (vite, eslint, jest…)')
     logger.info('')
-    logger.info('⚠  Files were REMOVED from root.')
-    logger.info('   Run the following before deploying or starting the project:')
-    logger.info('')
-    logger.info('   rootless prepare   — copies files back to root')
+    logger.info('Start your server:')
+    logger.info('  rootless run .server.run.cmd')
     logger.info('')
     logger.info('Other commands:')
     logger.info('  rootless status    — show what is managed')
     logger.info('  rootless watch     — auto-sync .root/ → root on changes')
+    logger.info('  rootless repatch   — re-apply server script patches')
     logger.info('─────────────────────────────────────────')
   },
 }

package/src/core/scriptPatcher.js

@@ -479,50 +479,74 @@ function patchServerScript(content) {
   // Only patch scripts that use $PSScriptRoot as web root
   if (!content.includes('$PSScriptRoot') || !content.includes('$root')) return null
 
+  // Idempotency guard — already patched by rootless
+  if (content.includes('# <rootless>')) return null
+
+  // Must have the `$root = $PSScriptRoot` assignment to know where to inject
+  if (!/^[ \t]*\$root[ \t]*=[ \t]*\$PSScriptRoot/m.test(content)) return null
+
   let out = content
 
-  // 1. Redefine $root → project root (2 levels up), keep $assetsRoot for fallback
+  // 1. Replace `$root = $PSScriptRoot...` with a runtime-detection block.
+  //    Works whether the script lives in .root/assets/ OR has been copied back
+  //    to the project root (e.g. via 'git checkout' or 'rootless prepare').
+  //    Using () => replacement to prevent '$' being treated as a regex backreference.
   out = out.replace(
-    /\$root(\s*)=(\s*)\$PSScriptRoot\.TrimEnd\('\\\\?'\)\s*\+\s*'\\\\'?/,
-    `$assetsRoot$1=$2$PSScriptRoot.TrimEnd('\\') + '\\'
-$root$1=$2(Get-Item "$PSScriptRoot\\..\\..").FullName.TrimEnd('\\') + '\\'`
+    /^[ \t]*\$root[ \t]*=[ \t]*\$PSScriptRoot[^\n]*/m,
+    () => [
+      '# <rootless>',
+      '# Runtime-detect location — works from .root/assets/ AND from project root',
+      "if ($PSScriptRoot -match [regex]::Escape([System.IO.Path]::Combine('.root', 'assets'))) {",
+      "    $assetsRoot = $PSScriptRoot.TrimEnd('\\') + '\\'",
+      "    $root       = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot '..\\..')).TrimEnd('\\') + '\\'",
+      '} else {',
+      "    $root       = $PSScriptRoot.TrimEnd('\\') + '\\'",
+      "    $assetsRoot = [System.IO.Path]::GetFullPath((Join-Path $root ('.root' + [System.IO.Path]::DirectorySeparatorChar + 'assets'))).TrimEnd('\\') + '\\'",
+      '}',
+      '# </rootless>',
+    ].join('\n')
   )
 
-  // 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. After file-path resolution, fall back to $assetsRoot when the file is not
+  //    found under the project root (handles files that stayed in .root/assets/).
+  out = out.replace(
+    /^([ \t]+)(\$filePath[ \t]*=[ \t]*\$resolved)[ \t]*$/m,
+    (_, indent, line) => [
+      `${indent}${line}`,
+      `${indent}# rootless: fallback to .root/assets/ when file not found in project root`,
+      `${indent}if ($relPath -ne '' -and -not (Test-Path $filePath)) {`,
+      `${indent}    $assetsCandidate = [System.IO.Path]::GetFullPath((Join-Path $assetsRoot $relPath))`,
+      `${indent}    if (Test-Path $assetsCandidate) { $filePath = $assetsCandidate }`,
+      `${indent}}`,
+    ].join('\n')
+  )
 
-  // 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. Replace `if (Test-Path $filePath -PathType Leaf)` with:
+  //    a) $assetsRoot directory fallback (when $root dir has no index.html)
+  //    b) null guard  ($filePath can be $null after a directory miss — Test-Path $null throws)
+  out = out.replace(
+    /^([ \t]+)(if \(Test-Path \$filePath -PathType Leaf\) \{)[ \t]*$/m,
+    (_, indent) => [
+      `${indent}# rootless: if $root dir had no index, check $assetsRoot dir too`,
+      `${indent}if ($filePath -eq $null -and $relPath -ne '') {`,
+      `${indent}    $assetsDir = [System.IO.Path]::GetFullPath((Join-Path $assetsRoot $relPath))`,
+      `${indent}    foreach ($idx in @('index.html', 'index.htm')) {`,
+      `${indent}        $idxPath = Join-Path $assetsDir $idx`,
+      `${indent}        if (Test-Path $idxPath -PathType Leaf) { $filePath = $idxPath; break }`,
+      `${indent}    }`,
+      `${indent}}`,
+      `${indent}if ($filePath -ne $null -and (Test-Path $filePath -PathType Leaf)) {`,
+    ].join('\n')
+  )
 
-  // 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 }`
-    )
-  }
+  // 4. 404 page lookup — also try $assetsRoot when the file isn't under $root
+  out = out.replace(
+    /^([ \t]+)(\$candidate[ \t]*=[ \t]*Join-Path \$root \$filename)[ \t]*$/m,
+    (_, indent, line) => [
+      `${indent}${line}`,
+      `${indent}if (-not (Test-Path $candidate -PathType Leaf)) { $candidate = Join-Path $assetsRoot $filename }`,
+    ].join('\n')
+  )
 
   return out === content ? null : out
 }