rootless-config 1.4.5 → 1.5.0

package/package.json

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

package/src/cli/commands/serve.js

@@ -0,0 +1,176 @@
+/*-------- rootless serve — virtual static server --------*/
+// Serves files from projectRoot first, then falls back to .root/assets/
+// Files never need to be copied to root for local development.
+
+import http from 'node:http'
+import path from 'node:path'
+import { readFile, stat } from 'node:fs/promises'
+import { createLogger } from '../../utils/logger.js'
+
+const DEFAULT_PORT = 3000
+
+const MIME = {
+  '.html':        'text/html; charset=utf-8',
+  '.htm':         'text/html; charset=utf-8',
+  '.md':          'text/markdown; charset=utf-8',
+  '.css':         'text/css; charset=utf-8',
+  '.js':          'application/javascript; charset=utf-8',
+  '.mjs':         'application/javascript; charset=utf-8',
+  '.cjs':         'application/javascript; charset=utf-8',
+  '.ts':          'application/typescript; charset=utf-8',
+  '.json':        'application/json; charset=utf-8',
+  '.webmanifest': 'application/manifest+json; charset=utf-8',
+  '.xml':         'application/xml; charset=utf-8',
+  '.txt':         'text/plain; charset=utf-8',
+  '.png':         'image/png',
+  '.jpg':         'image/jpeg',
+  '.jpeg':        'image/jpeg',
+  '.gif':         'image/gif',
+  '.svg':         'image/svg+xml',
+  '.ico':         'image/x-icon',
+  '.webp':        'image/webp',
+  '.avif':        'image/avif',
+  '.woff':        'font/woff',
+  '.woff2':       'font/woff2',
+  '.ttf':         'font/ttf',
+  '.otf':         'font/otf',
+  '.eot':         'application/vnd.ms-fontobject',
+  '.pdf':         'application/pdf',
+  '.zip':         'application/zip',
+  '.map':         'application/json',
+}
+
+function getMime(filePath) {
+  const ext = path.extname(filePath).toLowerCase()
+  return MIME[ext] ?? 'application/octet-stream'
+}
+
+async function isFile(p) {
+  try {
+    return (await stat(p)).isFile()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Try to resolve a URL path to a real file across multiple search directories.
+ * For directory requests also tries index.html / index.htm inside that dir.
+ */
+async function resolveFile(requestPath, searchDirs) {
+  // Normalize: remove leading slash, decode
+  const rel = requestPath.replace(/^\//, '') || ''
+
+  for (const dir of searchDirs) {
+    // Skip .root itself to avoid serving internal rootless files
+    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) {
+      if (await isFile(candidate)) return candidate
+    }
+  }
+
+  return null
+}
+
+export default {
+  name: 'serve',
+  description: 'Virtual static server — serves from root + .root/assets/ without copying files',
+
+  async handler(args) {
+    const logger = createLogger({ verbose: args.verbose ?? false })
+    const port   = parseInt(args.port ?? DEFAULT_PORT, 10)
+    const projectRoot   = args.cwd ? path.resolve(args.cwd) : process.cwd()
+    const containerPath = path.join(projectRoot, '.root')
+    const assetsDir     = path.join(containerPath, 'assets')
+    const envDir        = path.join(containerPath, 'env')
+
+    // Lookup order: real root first → .root/assets/ → .root/env/
+    // This means files physically in root always win.
+    const searchDirs = [projectRoot, assetsDir, envDir]
+
+    const server = http.createServer(async (req, res) => {
+      try {
+        const url         = new URL(req.url, `http://localhost:${port}`)
+        const requestPath = decodeURIComponent(url.pathname)
+
+        // Block access to .root internals
+        if (requestPath.startsWith('/.root')) {
+          res.writeHead(403, { 'Content-Type': 'text/plain' })
+          res.end('Forbidden')
+          return
+        }
+
+        const filePath = await resolveFile(requestPath, searchDirs)
+
+        if (filePath) {
+          const content = await readFile(filePath)
+          res.writeHead(200, {
+            'Content-Type':  getMime(filePath),
+            'Cache-Control': 'no-cache',
+          })
+          res.end(content)
+
+          const source = filePath.startsWith(assetsDir)
+            ? '.root/assets'
+            : filePath.startsWith(envDir)
+              ? '.root/env'
+              : 'root'
+          logger.info(`200  GET  ${requestPath}  [${source}]`)
+          return
+        }
+
+        // 404 — try to serve custom error page from .root or root
+        const notFoundPage = await resolveFile('/404.html', searchDirs)
+          ?? await resolveFile('/404.htm', searchDirs)
+          ?? await resolveFile('/404.md',  searchDirs)
+
+        res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' })
+        if (notFoundPage) {
+          res.end(await readFile(notFoundPage))
+        } else {
+          res.end('<h1>404 Not Found</h1>')
+        }
+        logger.info(`404  ${requestPath}`)
+
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' })
+        res.end('Internal Server Error')
+        logger.fail(`500  ${req.url}: ${err.message}`)
+      }
+    })
+
+    server.listen(port, () => {
+      logger.success(`Virtual server running at http://localhost:${port}`)
+      logger.info('')
+      logger.info('Serving from (in order):')
+      logger.info(`  [1] ${projectRoot}`)
+      logger.info(`  [2] ${assetsDir}`)
+      logger.info(`  [3] ${envDir}`)
+      logger.info('')
+      logger.info('Files in .root/ are served AS IF they are in root.')
+      logger.info('No need to run rootless prepare for local development.')
+      logger.info('')
+      logger.info('Press Ctrl+C to stop.')
+    })
+
+    // Keep process alive until Ctrl+C
+    await new Promise((_resolve, reject) => {
+      server.on('error', reject)
+      process.on('SIGINT', () => {
+        logger.info('\nServer stopped.')
+        server.close()
+        process.exit(0)
+      })
+    })
+  },
+}

package/src/cli/commands/setup.js

@@ -1,21 +1,62 @@
-/*-------- rootless setup — one-command full root cleanup: init + migrate + prepare --------*/
+/*-------- rootless setup — one-command full root cleanup: init + normalize + migrate --------*/
 
 import path from 'node:path'
+import { readdir, rename } from 'node:fs/promises'
 import { createLogger } from '../../utils/logger.js'
+import { fileExists, ensureDir } from '../../utils/fsUtils.js'
+import { isPatchable } from '../../core/scriptPatcher.js'
 import initCmd from './init.js'
 import migrateCmd from './migrate.js'
-import prepareCmd from './prepare.js'
+
+/**
+ * Fix files that ended up in the wrong subfolder from a previous run.
+ * Non-patchable files (web assets, docs, scripts) belong in assets/, not configs/.
+ */
+async function normalizeContainer(containerPath, logger) {
+  const configsDir = path.join(containerPath, 'configs')
+  const assetsDir  = path.join(containerPath, 'assets')
+  if (!(await fileExists(configsDir))) return
+
+  const entries = await readdir(configsDir, { withFileTypes: true })
+  for (const e of entries) {
+    if (!e.isFile()) continue
+    if (!isPatchable(e.name)) {
+      // Not a tool config — belongs in assets/
+      await ensureDir(assetsDir)
+      await rename(
+        path.join(configsDir, e.name),
+        path.join(assetsDir, e.name)
+      )
+      logger.debug(`Normalized: .root/configs/${e.name} → .root/assets/${e.name}`)
+    }
+  }
+}
+
+/**
+ * Count total files managed across all .root subdirectories.
+ */
+async function countRootFiles(containerPath) {
+  let total = 0
+  for (const sub of ['env', 'assets', 'configs']) {
+    const dir = path.join(containerPath, sub)
+    if (!(await fileExists(dir))) continue
+    const entries = await readdir(dir, { withFileTypes: true })
+    total += entries.filter(e => e.isFile()).length
+  }
+  return total
+}
 
 export default {
   name: 'setup',
-  description: 'Full automated root cleanup: init .root, migrate all configs, prepare (copy + patch scripts)',
+  description: 'Full automated root cleanup: move ALL files into .root container (run prepare to deploy)',
 
   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')
 
     logger.info('─────────────────────────────────────────')
-    logger.info(' rootless setup — cleaning your project root')
+    logger.info(' rootless setup — moving everything to .root/')
     logger.info('─────────────────────────────────────────')
     logger.info('')
 
@@ -24,31 +65,36 @@ export default {
     await initCmd.handler({ ...args, yes: true, cwd: projectRoot })
     logger.info('')
 
-    // ── Step 2: migrate ───────────────────────────────────────────────────────
-    logger.info('[2/3] Migrating config files from root…')
-    await migrateCmd.handler({ ...args, yes: true, cwd: projectRoot })
+    // ── Step 2: normalize existing .root structure (fix misrouted files) ──────
+    logger.info('[2/3] Normalizing .root structure…')
+    await normalizeContainer(containerPath, logger)
+    logger.success('Structure normalized')
     logger.info('')
 
-    // ── Step 3: prepare ───────────────────────────────────────────────────────
-    logger.info('[3/3] Preparing root (copying mandatory files + patching scripts)…')
-    await prepareCmd.handler({ ...args, yes: true })
+    // ── Step 3: migrate ALL files from root → .root/ ──────────────────────────
+    logger.info('[3/3] Migrating files from root to .root/…')
+    await migrateCmd.handler({ ...args, yes: true, cwd: projectRoot })
     logger.info('')
 
+    const total = await countRootFiles(containerPath)
+
     logger.info('─────────────────────────────────────────')
-    logger.success('Setup complete! Your project root is clean.')
-    logger.info('')
-    logger.info('What happened:')
-    logger.info('  • .root/ container created')
-    logger.info('  • Config files moved to .root/configs/')
-    logger.info('  • .env* files moved to .root/env/')
-    logger.info('  • Web assets moved to .root/assets/')
-    logger.info('  • package.json scripts patched with --config flags')
-    logger.info('  • Mandatory files copied back to root (prepare)')
-    logger.info('')
-    logger.info('Next steps:')
-    logger.info('  rootless status   — see what\'s managed')
-    logger.info('  rootless doctor   — verify everything is wired correctly')
-    logger.info('  rootless watch    — auto-sync on .root/ changes')
+    logger.success(`Setup complete! ${total} files now managed in .root/`)
+    logger.info('')
+    logger.info('Your project root is now clean.')
+    logger.info('')
+    logger.info('  .root/env/     — .env files')
+    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('')
+    logger.info('Other commands:')
+    logger.info('  rootless status    — show what is managed')
+    logger.info('  rootless watch     — auto-sync .root/ → root on changes')
     logger.info('─────────────────────────────────────────')
   },
 }

package/src/cli/index.js

@@ -25,6 +25,10 @@ async function run(argv) {
       sub.option('--no-yes', 'Auto-decline all file override prompts')
     }
 
+    if (cmd.name === 'serve') {
+      sub.option('--port <number>', 'Port to listen on (default: 3000)')
+    }
+
     sub.option('--verbose', 'Enable verbose output')
     sub.option('--silent', 'Suppress all output')