rootless-config 1.5.0 → 1.6.1

package/package.json

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

package/src/cli/commands/activate.js

@@ -0,0 +1,144 @@
+/*-------- rootless activate — install PS profile hook for auto PATH injection --------*/
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import os from 'node:os'
+import { spawn } from 'node:child_process'
+import { fileExists } from '../../utils/fsUtils.js'
+import { createLogger } from '../../utils/logger.js'
+
+// The block we inject into $PROFILE — delimited so we can detect/remove it
+const HOOK_START = '# <rootless-hook>'
+const HOOK_END   = '# </rootless-hook>'
+
+const HOOK_BODY = `
+# <rootless-hook>
+# Auto-injected by rootless-config — adds .root/assets + .root/configs to PATH
+# when entering a project that has a .root/ container.
+function _Rootless_Activate {
+    param([string]$Dir = $PWD)
+    $rootPath = Join-Path $Dir ".root"
+    if (-not (Test-Path $rootPath -PathType Container)) { return }
+    $slots = @(
+        (Join-Path $rootPath "assets"),
+        (Join-Path $rootPath "configs")
+    )
+    foreach ($slot in $slots) {
+        if ((Test-Path $slot) -and ($env:PATH -notlike "*$slot*")) {
+            $env:PATH = "$slot;$env:PATH"
+        }
+    }
+}
+
+# Hook into the prompt so activation runs after every cd
+$_RootlessOriginalPrompt = if (Get-Command prompt -ErrorAction SilentlyContinue) {
+    ${function:prompt}
+} else { $null }
+
+function global:prompt {
+    _Rootless_Activate
+    if ($_RootlessOriginalPrompt) {
+        & $_RootlessOriginalPrompt
+    } else {
+        "PS $($PWD)> "
+    }
+}
+
+# Activate immediately for current directory
+_Rootless_Activate
+# </rootless-hook>
+`
+
+async function getProfilePath() {
+  // Ask PowerShell for the actual profile path
+  return new Promise((resolve) => {
+    let out = ''
+    const ps = spawn('powershell', ['-NoProfile', '-Command', 'echo $PROFILE'], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    ps.stdout.on('data', d => { out += d.toString() })
+    ps.on('exit', () => resolve(out.trim()))
+  })
+}
+
+async function readProfile(profilePath) {
+  try { return await readFile(profilePath, 'utf8') } catch { return '' }
+}
+
+async function isHookInstalled(profilePath) {
+  const content = await readProfile(profilePath)
+  return content.includes(HOOK_START)
+}
+
+async function installHook(profilePath) {
+  await mkdir(path.dirname(profilePath), { recursive: true })
+  const existing = await readProfile(profilePath)
+  await writeFile(profilePath, existing + '\n' + HOOK_BODY, 'utf8')
+}
+
+async function removeHook(profilePath) {
+  const content = await readProfile(profilePath)
+  const startIdx = content.indexOf(HOOK_START)
+  const endIdx   = content.indexOf(HOOK_END)
+  if (startIdx === -1) return false
+  const cleaned = content.slice(0, startIdx) + content.slice(endIdx + HOOK_END.length)
+  await writeFile(profilePath, cleaned.trim() + '\n', 'utf8')
+  return true
+}
+
+export default {
+  name: 'activate',
+  description: 'Install PowerShell profile hook — .root/ files become available as commands automatically',
+
+  async handler(args) {
+    const logger = createLogger({ verbose: args.verbose ?? false })
+
+    // --remove flag
+    if (args.remove) {
+      const profilePath = await getProfilePath()
+      const removed = await removeHook(profilePath)
+      if (removed) {
+        logger.success('Rootless hook removed from PowerShell profile.')
+      } else {
+        logger.info('No rootless hook found in profile.')
+      }
+      return
+    }
+
+    // --env flag: just print the activation snippet for current session
+    if (args.env) {
+      process.stdout.write(HOOK_BODY + '\n')
+      return
+    }
+
+    const profilePath = await getProfilePath()
+
+    if (await isHookInstalled(profilePath)) {
+      logger.success('Rootless hook already installed.')
+      logger.info(`Profile: ${profilePath}`)
+      logger.info('')
+      logger.info('Already active in all new PowerShell sessions.')
+      logger.info('To activate in THIS session right now:')
+      logger.info('')
+      logger.info('  rootless activate --env | Invoke-Expression')
+      return
+    }
+
+    await installHook(profilePath)
+
+    logger.success('Rootless hook installed!')
+    logger.info(`Profile: ${profilePath}`)
+    logger.info('')
+    logger.info('From now on, in ANY new PowerShell session:')
+    logger.info('  → navigate to a project with .root/')
+    logger.info('  → all files in .root/assets/ and .root/configs/ are in PATH')
+    logger.info('  → type .server.run, .server.ps1 etc. directly')
+    logger.info('')
+    logger.info('To activate in THIS session right now:')
+    logger.info('')
+    logger.info('  rootless activate --env | Invoke-Expression')
+    logger.info('')
+    logger.info('To remove the hook later:')
+    logger.info('  rootless activate --remove')
+  },
+}

package/src/cli/commands/run.js

@@ -0,0 +1,95 @@
+/*-------- rootless run — execute a file from .root/ as if it were in project root --------*/
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { fileExists } from '../../utils/fsUtils.js'
+import { createLogger } from '../../utils/logger.js'
+
+// Search for a filename across all .root subdirectories
+async function findInRoot(containerPath, name) {
+  // Strip leading ./ or .\ (user might type .\.server.ps1)
+  const base = name.replace(/^\.[\\/]/g, '')
+  for (const sub of ['assets', 'configs', 'env']) {
+    const candidate = path.join(containerPath, sub, base)
+    if (await fileExists(candidate)) return candidate
+  }
+  return null
+}
+
+function buildSpawnArgs(filePath, extraArgs) {
+  const ext = path.extname(filePath).toLowerCase()
+  if (ext === '.ps1') {
+    return {
+      cmd: 'powershell',
+      args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', filePath, ...extraArgs],
+    }
+  }
+  if (ext === '.cmd' || ext === '.bat') {
+    return { cmd: 'cmd', args: ['/c', filePath, ...extraArgs] }
+  }
+  if (ext === '.sh') {
+    return { cmd: 'bash', args: [filePath, ...extraArgs] }
+  }
+  return { cmd: filePath, args: extraArgs }
+}
+
+export default {
+  name: 'run',
+  description: 'Run a file from .root/ as if it were in project root — no file copying',
+
+  async handler(args) {
+    const logger = createLogger({ verbose: args.verbose ?? false })
+    const scriptArgs = args.scriptArgs ?? []
+
+    if (scriptArgs.length === 0) {
+      logger.fail('No file specified.')
+      logger.info('Usage:   rootless run <file> [args...]')
+      logger.info('Example: rootless run .server.ps1')
+      logger.info('Example: rootless run .server.run.cmd')
+      process.exitCode = 1
+      return
+    }
+
+    const projectRoot   = args.cwd ? path.resolve(args.cwd) : process.cwd()
+    const containerPath = path.join(projectRoot, '.root')
+    const [name, ...rest] = scriptArgs
+
+    // Check project root first, then .root subdirs
+    const inRoot = path.join(projectRoot, name.replace(/^\.[\\/]/g, ''))
+    let filePath = (await fileExists(inRoot)) ? inRoot : await findInRoot(containerPath, name)
+
+    if (!filePath) {
+      logger.fail(`Not found: "${name}"`)
+      logger.info('Searched: project root, .root/assets/, .root/configs/, .root/env/')
+      process.exitCode = 1
+      return
+    }
+
+    const rel = filePath.startsWith(containerPath)
+      ? `.root/${path.relative(containerPath, filePath).replace(/\\/g, '/')}`
+      : path.relative(projectRoot, filePath)
+
+    logger.info(`Running: ${name}  [${rel}]`)
+    logger.info(`cwd:     ${projectRoot}`)
+    logger.info('')
+
+    const { cmd, args: cmdArgs } = buildSpawnArgs(filePath, rest)
+
+    const child = spawn(cmd, cmdArgs, {
+      cwd:   projectRoot,  // always runs from project root
+      stdio: 'inherit',
+      shell: false,
+    })
+
+    child.on('error', (err) => {
+      logger.fail(`Failed to start: ${err.message}`)
+      process.exitCode = 1
+    })
+
+    await new Promise(resolve => child.on('exit', (code) => {
+      process.exitCode = code ?? 0
+      resolve()
+    }))
+  },
+}
+

package/src/cli/commands/shell.js

@@ -0,0 +1,118 @@
+/*-------- rootless shell — interactive shell where .root/ files act as if in project root --------*/
+
+import { spawn } from 'node:child_process'
+import { writeFile, unlink, readdir } from 'node:fs/promises'
+import path from 'node:path'
+import os from 'node:os'
+import { fileExists } from '../../utils/fsUtils.js'
+import { createLogger } from '../../utils/logger.js'
+
+/**
+ * Build a temporary PowerShell profile that:
+ *  1. Adds .root/assets/ to PATH (so .cmd/.bat/.exe files are runnable by name)
+ *  2. Creates a function wrapper for each .ps1 file so it's callable by name
+ *  3. Overrides prompt to show [rootless] prefix
+ */
+async function buildPsProfile(projectRoot, containerPath) {
+  const assetsDir  = path.join(containerPath, 'assets')
+  const configsDir = path.join(containerPath, 'configs')
+  const envDir     = path.join(containerPath, 'env')
+
+  const lines = []
+
+  // Add .root/assets/ and .root/configs/ to PATH for executable resolution
+  lines.push(`$env:PATH = "${assetsDir};${configsDir};$env:PATH"`)
+  lines.push('')
+
+  // Create function wrappers for every .ps1 file in .root/
+  for (const dir of [assetsDir, configsDir]) {
+    if (!(await fileExists(dir))) continue
+    const entries = await readdir(dir, { withFileTypes: true })
+    for (const e of entries) {
+      if (!e.isFile() || !e.name.endsWith('.ps1')) continue
+      const fullPath = path.join(dir, e.name).replace(/\\/g, '\\\\')
+      // Function name: strip leading dot for valid PS identifier, but also set alias with dot
+      const safeName = e.name.replace(/^\./, '_').replace(/\.ps1$/, '')
+      const dotName  = e.name.replace(/\.ps1$/, '')  // e.g. ".server"
+      lines.push(`function global:${safeName} { & "${fullPath}" @args }`)
+      // Also register the dotted version via alias if it doesn't start with dot
+      if (!dotName.startsWith('.')) {
+        lines.push(`Set-Alias -Name "${dotName}.ps1" -Value ${safeName} -Scope Global`)
+      }
+    }
+  }
+
+  lines.push('')
+  lines.push('# Prompt')
+  lines.push('function global:prompt {')
+  lines.push('  Write-Host "[rootless] " -NoNewline -ForegroundColor Cyan')
+  lines.push('  Write-Host (Get-Location) -NoNewline -ForegroundColor White')
+  lines.push('  return "> "')
+  lines.push('}')
+  lines.push('')
+
+  // Welcome banner
+  lines.push('Write-Host ""')
+  lines.push('Write-Host "  Rootless Shell" -ForegroundColor Cyan')
+  lines.push('Write-Host "  Files from .root/ work as commands. cwd = project root." -ForegroundColor Gray')
+  lines.push('Write-Host "  Type exit to leave." -ForegroundColor Gray')
+  lines.push('Write-Host ""')
+
+  // List available .ps1 wrappers
+  lines.push('Write-Host "  Available:" -ForegroundColor DarkCyan')
+  for (const dir of [assetsDir, configsDir]) {
+    if (!(await fileExists(dir))) continue
+    const entries = await readdir(dir, { withFileTypes: true })
+    for (const e of entries) {
+      if (!e.isFile()) continue
+      const rel = `.root/${path.basename(dir)}/${e.name}`
+      lines.push(`Write-Host "    ${e.name.padEnd(30)} [${rel}]" -ForegroundColor Gray`)
+    }
+  }
+  lines.push('Write-Host ""')
+
+  return lines.join('\n')
+}
+
+export default {
+  name: 'shell',
+  description: 'Open an interactive shell where .root/ files are accessible as commands',
+
+  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.fail('No .root/ container found. Run: rootless setup')
+      process.exitCode = 1
+      return
+    }
+
+    // Write temp profile
+    const profilePath = path.join(os.tmpdir(), `rootless-profile-${Date.now()}.ps1`)
+    const profileContent = await buildPsProfile(projectRoot, containerPath)
+    await writeFile(profilePath, profileContent, 'utf8')
+
+    logger.info('Starting rootless shell…')
+
+    const child = spawn(
+      'powershell',
+      ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-NoExit', '-Command', `. "${profilePath}"`],
+      {
+        cwd:   projectRoot,
+        stdio: 'inherit',
+        shell: false,
+      }
+    )
+
+    child.on('error', async (err) => {
+      logger.fail(`Failed to start shell: ${err.message}`)
+      await unlink(profilePath).catch(() => {})
+      process.exitCode = 1
+    })
+
+    await new Promise(resolve => child.on('exit', resolve))
+    await unlink(profilePath).catch(() => {})
+  },
+}

package/src/cli/index.js

@@ -25,19 +25,33 @@ async function run(argv) {
       sub.option('--no-yes', 'Auto-decline all file override prompts')
     }
 
+    if (cmd.name === 'activate') {
+      sub.option('--remove', 'Remove the hook from PowerShell profile')
+      sub.option('--env',    'Print activation snippet for current session only (pipe to Invoke-Expression)')
+    }
+
     if (cmd.name === 'serve') {
       sub.option('--port <number>', 'Port to listen on (default: 3000)')
     }
 
+    if (cmd.name === 'run') {
+      sub.argument('[scriptArgs...]', 'File to run and optional arguments')
+      sub.passThroughOptions(true)
+    }
+
     sub.option('--verbose', 'Enable verbose output')
     sub.option('--silent', 'Suppress all output')
 
-    sub.action(async (options) => {
+    sub.action(async (scriptArgsOrOptions, options) => {
+      // For 'run' command, first arg is the positional array
+      const opts = cmd.name === 'run'
+        ? { ...options, scriptArgs: scriptArgsOrOptions }
+        : scriptArgsOrOptions
       try {
-        await cmd.handler(options)
+        await cmd.handler(opts)
       } catch (err) {
         logger.fail(err.message)
-        if (options.verbose) process.stderr.write(err.stack + '\n')
+        if (opts.verbose) process.stderr.write(err.stack + '\n')
         process.exitCode = 1
       }
     })