@noego/app 0.0.6 → 0.0.9

package/.claude/settings.local.json

@@ -3,7 +3,8 @@
     "allow": [
       "Bash(cat:*)",
       "Bash(curl:*)",
-      "Bash(noego dev)"
+      "Bash(noego dev)",
+      "WebSearch"
     ],
     "deny": [],
     "ask": []

package/DEVELOPING.md

@@ -0,0 +1,73 @@
+**Purpose**
+- Run and test dev watchers without blocking your terminal.
+- Verify backend/frontend restarts on file changes using short, backgrounded runs with logs and PIDs.
+
+**Prerequisites**
+- Node 20+.
+- This repo installed (run `npm install` once).
+
+**Local Watch Harness (Fast, Backgrounded)**
+- Start (runs ~10–15s, then exits on its own):
+  - `Timestamp=$(date +%s); LOG=watch-harness-$Timestamp.log; node scripts/watch-harness.mjs > $LOG 2>&1 & echo $! > watch-harness.pid`
+- Observe:
+  - `tail -f $LOG`
+  - Look for lines like:
+    - `🔄 change detected (change): server/stitch.yaml` (BACKEND)
+    - `🔄 change detected (change): hammer.config.yml` (SHARED)
+    - `🚀 [backend restart #X]` / `🚀 [frontend restart #X]`
+    - `✅ restart sequence complete`
+- Stop (if ever needed):
+  - `kill $(cat watch-harness.pid)`
+- What it does
+  - Seeds a temp tree under `.watch-harness/`.
+  - Watches directories (server/ui/middleware/openapi/repo) and classifies events using your globs.
+  - Spawns mock backend/frontend child processes, simulates backend/frontend/shared changes, restarts the right process(es), then shuts down.
+
+**Real App Dev (noblelaw) in Background**
+- Start dev for the noblelaw project in the background with logs:
+  - `NO_COLOR=1 node ./bin/app.js dev --root /Users/shavauhngabay/dev/noblelaw > noblelaw-dev.log 2>&1 & echo $! > noblelaw-dev.pid`
+- Observe:
+  - `tail -f noblelaw-dev.log`
+  - Expect on startup: backend on port 3002, frontend (Vite) on 3001, router on 3000.
+  - Make edits to trigger restarts:
+    - Backend restart: edit `server/services/*.ts`, `middleware/**/*.ts`, `server/openapi/**/*.yaml`, or `server/repo/**/*.sql`.
+    - Frontend restart: edit `ui/**/*.ts`, `ui/openapi/**/*.yaml`.
+    - Shared restart: edit `index.ts` or `hammer.config.yml`.
+    - Note: `.svelte` changes do not restart the server; Vite HMR handles them.
+  - Look for logs:
+    - `🔄 FILE CHANGE DETECTED: …`
+    - `Type: BACKEND | FRONTEND | SHARED`
+    - `🚀 [RESTART #…] Starting …`
+    - `✅ Restart complete`
+- Stop:
+  - `kill $(cat noblelaw-dev.pid)`
+- Free busy ports (if you see EADDRINUSE):
+  - `for p in 3000 3001 3002; do P=$(lsof -t -nP -iTCP:$p -sTCP:LISTEN 2>/dev/null); [ -n "$P" ] && kill -9 $P; done`
+
+**How The Watcher Works**
+- Chokidar now watches concrete directories/files so it always attaches:
+  - Directories: `server/`, `ui/`, `middleware/`, `server/openapi/`, `server/repo/`, `ui/openapi/`.
+  - Files: `index.ts`, `hammer.config.yml`, `server/stitch.yaml`, `ui/stitch.yaml`.
+- Classification still uses your original globs (picomatch):
+  - Backend: `server/**/*.ts`, `middleware/**/*.ts`, `server/stitch.yaml`, `server/openapi/**/*.yaml`, `server/repo/**/*.sql`.
+  - Frontend: `ui/**/*.ts`, `ui/stitch.yaml`, `ui/openapi/**/*.yaml`.
+  - Shared: `index.ts`, `hammer.config.yml` (plus any app-level watch entries).
+- This avoids the “ready but no watchers” problem when globs don’t match initial files.
+
+**Troubleshooting**
+- No restart logs after editing a file:
+  - Confirm the file lives under a watched directory and matches one of the classification globs above.
+  - `.svelte` isn’t supposed to restart—use Vite HMR in the browser.
+- Watcher error (EMFILE or similar):
+  - The CLI now fails fast on watcher errors with a clear log and exit.
+  - Ensure you’re not watching the entire repo root or `node_modules/`; keep to `server/`, `ui/`, `middleware/` and the specific YAML/SQL roots.
+- Ports in use (EADDRINUSE):
+  - Free 3000/3001/3002 using the snippet above and restart dev.
+- Clean up stray mock processes from the harness (if any):
+  - `pkill -f "\[backend\]"; pkill -f "\[frontend\]"`
+
+**Operational Tips**
+- Always background long-running scripts and write the PID to a file.
+- Tail logs for verification and kill by PID when done.
+- Keep a hard timeout in any custom test harness so it self-exits if something goes wrong.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/app",
-  "version": "0.0.6",
+  "version": "0.0.9",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {
@@ -14,6 +14,10 @@
     "./client": {
       "import": "./src/client.js",
       "types": "./types/client.d.ts"
+    },
+    "./config": {
+      "import": "./src/runtime/config.js",
+      "types": "./types/config.d.ts"
     }
   },
   "scripts": {
@@ -25,6 +29,7 @@
   "license": "MIT",
   "author": "App Build CLI",
   "dependencies": {
+    "glob-parent": "^6.0.2",
     "deepmerge": "^4.3.1",
     "picomatch": "^2.3.1",
     "yaml": "^2.6.0"
@@ -34,5 +39,7 @@
     "@noego/forge": "*",
     "express": "*"
   },
-  "devDependencies": {}
+  "devDependencies": {
+    "chokidar": "^4.0.3"
+  }
 }

package/scripts/watch-harness.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import picomatch from 'picomatch';
+
+const PLAYGROUND_DIR = path.join(process.cwd(), '.watch-harness');
+const sharedPatterns = ['index.ts', 'hammer.config.yml'];
+const backendPatterns = [
+  'server/**/*.ts',
+  'middleware/**/*.ts',
+  'server/stitch.yaml',
+  'server/openapi/**/*.yaml',
+  'server/repo/**/*.sql'
+];
+const frontendPatterns = [
+  'ui/**/*.ts',
+  'ui/stitch.yaml',
+  'ui/openapi/**/*.yaml'
+];
+const allPatterns = [...sharedPatterns, ...backendPatterns, ...frontendPatterns];
+
+const seedFiles = {
+  'index.ts': '// root entry\n',
+  'hammer.config.yml': '# config\n',
+  'server/server.ts': '// server bootstrap\n',
+  'server/services/admin_service.ts': '// admin service seed\n',
+  'middleware/logger.ts': '// middleware seed\n',
+  'server/stitch.yaml': 'openapi: 3.0.0\n',
+  'server/openapi/routes.yaml': 'paths: {}\n',
+  'server/repo/example/query.sql': 'select 1;\n',
+  'ui/frontend.ts': '// frontend entry\n',
+  'ui/stitch.yaml': 'paths: {}\n',
+  'ui/openapi/page.yaml': 'paths: {}\n',
+  'ui/pages/home.ts': 'export const home = true;\n'
+};
+
+const changeSequence = [
+  { label: 'backend', file: 'server/services/admin_service.ts' },
+  { label: 'frontend', file: 'ui/pages/home.ts' },
+  { label: 'shared', file: 'hammer.config.yml' }
+];
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+let backendProc = null;
+let frontendProc = null;
+let watcher = null;
+let shuttingDown = false;
+let pendingRestart = false;
+let backendRestartCount = 0;
+let frontendRestartCount = 0;
+let readyHandled = false;
+
+async function preparePlayground() {
+  await fs.rm(PLAYGROUND_DIR, { recursive: true, force: true }).catch(() => {});
+  await fs.mkdir(PLAYGROUND_DIR, { recursive: true });
+  await Promise.all(
+    Object.entries(seedFiles).map(async ([relative, contents]) => {
+      const absolute = path.join(PLAYGROUND_DIR, relative);
+      await fs.mkdir(path.dirname(absolute), { recursive: true });
+      await fs.writeFile(absolute, contents);
+    })
+  );
+}
+
+function spawnChild(label) {
+  const child = spawn(process.execPath, ['-e', `
+    console.log('[${label}] booting (pid', process.pid, ')');
+    let counter = 0;
+    setInterval(() => {
+      counter += 1;
+      console.log('[${label}] heartbeat #' + counter);
+    }, 750);
+  `], {
+    stdio: ['ignore', 'inherit', 'inherit']
+  });
+  child.on('exit', (code, signal) => {
+    console.log(`[${label}] exited`, { code, signal });
+  });
+  return child;
+}
+
+function startBackend() {
+  backendRestartCount += 1;
+  console.log(`🚀 [backend restart #${backendRestartCount}] starting mock backend`);
+  backendProc = spawnChild('backend');
+}
+
+function startFrontend() {
+  frontendRestartCount += 1;
+  console.log(`🚀 [frontend restart #${frontendRestartCount}] starting mock frontend`);
+  frontendProc = spawnChild('frontend');
+}
+
+function stopProcess(proc, label) {
+  return new Promise((resolve) => {
+    if (!proc || proc.killed) {
+      return resolve();
+    }
+    const timeout = setTimeout(() => {
+      console.warn(`[${label}] did not exit in time, forcing SIGKILL`);
+      try {
+        proc.kill('SIGKILL');
+      } catch {}
+      resolve();
+    }, 2000);
+    proc.once('exit', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    try {
+      proc.kill('SIGTERM');
+    } catch {
+      clearTimeout(timeout);
+      resolve();
+    }
+  });
+}
+
+async function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log('[harness] shutting down...');
+  try {
+    if (watcher) {
+      await watcher.close();
+    }
+  } catch (error) {
+    console.error('[harness] watcher close error', error);
+  }
+  await stopProcess(backendProc, 'backend');
+  await stopProcess(frontendProc, 'frontend');
+  await fs.rm(PLAYGROUND_DIR, { recursive: true, force: true }).catch(() => {});
+  process.exit(exitCode);
+}
+
+async function handleFileChange(reason, relativePath, matchers) {
+  if (pendingRestart) return;
+  pendingRestart = true;
+  const normalized = relativePath.replace(/\\/g, '/');
+  const { sharedMatcher, backendMatcher, frontendMatcher } = matchers;
+  let restartBackend = false;
+  let restartFrontend = false;
+
+  if (sharedMatcher && sharedMatcher(normalized)) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🔄 change detected (${reason}): ${normalized}`);
+    console.log('   type: SHARED -> restarting backend + frontend');
+    console.log(`${'='.repeat(60)}\n`);
+    restartBackend = true;
+    restartFrontend = true;
+  } else if (backendMatcher && backendMatcher(normalized)) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🔄 change detected (${reason}): ${normalized}`);
+    console.log('   type: BACKEND -> restarting backend only');
+    console.log(`${'='.repeat(60)}\n`);
+    restartBackend = true;
+  } else if (frontendMatcher && frontendMatcher(normalized)) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`🔄 change detected (${reason}): ${normalized}`);
+    console.log('   type: FRONTEND -> restarting frontend only');
+    console.log(`${'='.repeat(60)}\n`);
+    restartFrontend = true;
+  } else {
+    console.log(`[harness] change ignored (no matcher): ${normalized}`);
+  }
+
+  if (restartBackend) {
+    await stopProcess(backendProc, 'backend');
+    startBackend();
+  }
+  if (restartFrontend) {
+    await stopProcess(frontendProc, 'frontend');
+    startFrontend();
+  }
+  if (restartBackend || restartFrontend) {
+    console.log('✅ restart sequence complete\n');
+  }
+  pendingRestart = false;
+}
+
+async function simulateChanges() {
+  for (const step of changeSequence) {
+    await delay(500);
+    const target = path.join(PLAYGROUND_DIR, step.file);
+    console.log(`[harness] simulating ${step.label} change: ${step.file}`);
+    await fs.appendFile(target, `\n// touched ${Date.now()}`);
+  }
+  console.log('[harness] change simulation complete');
+}
+
+async function runHarness() {
+  await preparePlayground();
+
+  const normalizePattern = (pattern) => pattern;
+  const sharedMatcher = picomatch(sharedPatterns.map(normalizePattern));
+  const backendMatcher = picomatch(backendPatterns.map(normalizePattern));
+  const frontendMatcher = picomatch(frontendPatterns.map(normalizePattern));
+
+  watcher = chokidar.watch(allPatterns, {
+    cwd: PLAYGROUND_DIR,
+    ignoreInitial: true
+  });
+
+  const autoTimeout = setTimeout(() => {
+    console.error('[harness] timeout waiting for restarts');
+    shutdown(1);
+  }, 15000);
+
+  watcher.on('ready', async () => {
+    if (readyHandled) {
+      return;
+    }
+    readyHandled = true;
+    console.log('[harness] watcher ready');
+    startBackend();
+    startFrontend();
+    await simulateChanges();
+    setTimeout(async () => {
+      clearTimeout(autoTimeout);
+      await shutdown(0);
+    }, 1500);
+  });
+
+  watcher.on('all', (event, file) => {
+    if (!['add', 'change', 'unlink'].includes(event)) {
+      return;
+    }
+    handleFileChange(event, file, { sharedMatcher, backendMatcher, frontendMatcher });
+  });
+
+  watcher.on('error', async (error) => {
+    console.error('[harness] watcher error', error);
+    await shutdown(1);
+  });
+}
+
+process.on('SIGINT', () => shutdown(0));
+process.on('SIGTERM', () => shutdown(0));
+
+runHarness().catch((error) => {
+  console.error('[harness] fatal error', error);
+  shutdown(1);
+});

package/src/commands/dev.js

@@ -1,12 +1,48 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { spawn } from 'node:child_process';
+import { spawn, execSync } from 'node:child_process';
 import { createBuildContext } from '../build/context.js';
 import { findConfigFile } from '../runtime/index.js';
 import { loadConfig } from '../runtime/config-loader.js';
+import globParent from 'glob-parent';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Kill a process and all its descendants (entire process tree)
+ * This ensures no orphaned processes remain when killing a parent
+ */
+function killProcessTree(pid, signal = 'SIGKILL') {
+  if (!pid) return;
+
+  try {
+    // On Unix systems, use pkill to kill all descendants
+    if (process.platform !== 'win32') {
+      // Kill all child processes first
+      try {
+        execSync(`pkill -P ${pid}`, { stdio: 'ignore' });
+      } catch (e) {
+        // No children or already dead, that's fine
+      }
+      // Then kill the parent
+      try {
+        process.kill(pid, signal);
+      } catch (e) {
+        // Process may already be dead
+      }
+    } else {
+      // On Windows, use taskkill with /T flag to kill process tree
+      try {
+        execSync(`taskkill /pid ${pid} /T /F`, { stdio: 'ignore' });
+      } catch (e) {
+        // Process may already be dead
+      }
+    }
+  } catch (error) {
+    // Ignore errors - process might already be dead
+  }
+}
+
 export async function runDev(config) {
   const context = createBuildContext(config);
   const { logger } = context;
@@ -222,8 +258,14 @@ async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort,
     detached: false
   });
 
+  // Track if we're already shutting down
+  let isShuttingDown = false;
+
   // Handle shutdown
   const shutdown = (exitCode = 0) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
     logger.info('Shutting down split-serve processes...');
     if (backendProc && !backendProc.killed) {
       backendProc.kill('SIGTERM');
@@ -259,10 +301,34 @@ async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort,
     shutdown(1);
   });
 
-  // Set up signal handlers to clean up on termination
+  // Handle graceful shutdown signals
   process.on('SIGINT', () => shutdown(0));
   process.on('SIGTERM', () => shutdown(0));
 
+  // Handle process exit - ensures children are killed even if parent crashes
+  process.on('exit', () => {
+    // Synchronous cleanup only - exit event doesn't allow async
+    // Kill entire process tree (including tsx wrappers and their children)
+    if (backendProc && backendProc.pid && !backendProc.killed) {
+      killProcessTree(backendProc.pid);
+    }
+    if (frontendProc && frontendProc.pid && !frontendProc.killed) {
+      killProcessTree(frontendProc.pid);
+    }
+  });
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', (error) => {
+    logger.error('Uncaught exception:', error);
+    shutdown(1);
+  });
+
+  // Handle unhandled promise rejections
+  process.on('unhandledRejection', (reason, promise) => {
+    logger.error('Unhandled rejection at:', promise, 'reason:', reason);
+    shutdown(1);
+  });
+
   // Wait a moment for spawned processes to start
   await new Promise(resolve => setTimeout(resolve, 2000));
 
@@ -291,44 +357,74 @@ async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort,
  */
 async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv, yamlConfig, configFilePath, routerPort, frontendPort, backendPort, logger) {
   const { createRequire } = await import('node:module');
-  const root = yamlConfig.root || path.dirname(configFilePath);
+  // Use context.config.rootDir for consistency with spawned processes
+  const root = context.config.rootDir;
+  logger.debug(`Using root directory for file watching: ${root}`);
   const requireFromRoot = createRequire(path.join(root, 'package.json'));
   const chokidar = requireFromRoot('chokidar');
   const picomatch = (await import('picomatch')).default;
   
-  const resolvePattern = (pattern) => {
-    if (path.isAbsolute(pattern)) return pattern;
-    return path.resolve(root, pattern);
+  // Keep patterns relative for chokidar to work properly with globs
+  // Absolute patterns with globs don't work well, especially in chokidar v4
+  const normalizePattern = (pattern) => {
+    // If pattern is absolute, make it relative to root
+    if (path.isAbsolute(pattern)) {
+      const normalized = path.relative(root, pattern);
+      logger.debug(`Normalized pattern: ${pattern} -> ${normalized}`);
+      return normalized;
+    }
+    logger.debug(`Pattern already relative: ${pattern}`);
+    return pattern;
   };
-  
+
   // Collect watch patterns
   const backendPatterns = [];
   const frontendPatterns = [];
   const sharedPatterns = [];
-  
+
   // App watch patterns (restart both)
   if (yamlConfig.app?.watch) {
     for (const pattern of yamlConfig.app.watch) {
-      sharedPatterns.push(resolvePattern(pattern));
+      sharedPatterns.push(normalizePattern(pattern));
     }
   }
-  
+
   // Server watch patterns (restart backend only)
   if (yamlConfig.server?.watch) {
     for (const pattern of yamlConfig.server.watch) {
-      backendPatterns.push(resolvePattern(pattern));
+      backendPatterns.push(normalizePattern(pattern));
     }
   }
-  
+
   // Client watch patterns (restart frontend only)
   if (yamlConfig.client?.watch) {
     for (const pattern of yamlConfig.client.watch) {
-      frontendPatterns.push(resolvePattern(pattern));
+      frontendPatterns.push(normalizePattern(pattern));
     }
   }
   
-  // Combine all patterns for chokidar
+  // Combine all patterns (for classification)
   const allPatterns = [...sharedPatterns, ...backendPatterns, ...frontendPatterns];
+
+  // Derive concrete watch targets (directories/files) from the patterns
+  // We watch directories; we use picomatch on the original patterns to classify events.
+  const watchTargets = new Set();
+  const GLOB_CHARS = /[\\*?\[\]\{\}\(\)!+@]/; // simple glob detector
+  const addWatchTarget = (pattern) => {
+    if (!pattern) return;
+    const rel = normalizePattern(pattern);
+    // Negative patterns are for filtering; don't watch them directly
+    if (rel.startsWith('!')) return;
+    const isGlob = GLOB_CHARS.test(rel);
+    if (!isGlob) {
+      // Literal path; watch the file itself
+      watchTargets.add(rel);
+      return;
+    }
+    const base = globParent(rel);
+    watchTargets.add(base && base.length > 0 ? base : '.');
+  };
+  for (const p of allPatterns) addWatchTarget(p);
   
   if (allPatterns.length === 0) {
     logger.warn('No watch patterns configured. Watching disabled.');
@@ -339,18 +435,23 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   logger.info(`  Shared: ${sharedPatterns.length} patterns`);
   logger.info(`  Backend: ${backendPatterns.length} patterns`);
   logger.info(`  Frontend: ${frontendPatterns.length} patterns`);
+  logger.info(`  Watch targets (${watchTargets.size}): ${JSON.stringify(Array.from(watchTargets), null, 2)}`);
   
   // Create matchers
   const sharedMatcher = sharedPatterns.length > 0 ? picomatch(sharedPatterns) : null;
   const backendMatcher = backendPatterns.length > 0 ? picomatch(backendPatterns) : null;
   const frontendMatcher = frontendPatterns.length > 0 ? picomatch(frontendPatterns) : null;
-  
+
   let backendProc = null;
   let frontendProc = null;
   let pending = false;
-  
+  let backendRestartCount = 0;
+  let frontendRestartCount = 0;
+  let isShuttingDown = false;
+
   const startBackend = () => {
-    logger.info(`Starting backend on port ${backendPort}...`);
+    backendRestartCount++;
+    logger.info(`🚀 [RESTART #${backendRestartCount}] Starting backend on port ${backendPort}...`);
     const backendEnv = {
       ...baseEnv,
       NOEGO_SERVICE: 'backend',
@@ -372,7 +473,8 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   };
   
   const startFrontend = () => {
-    logger.info(`Starting frontend on port ${frontendPort}...`);
+    frontendRestartCount++;
+    logger.info(`🚀 [RESTART #${frontendRestartCount}] Starting frontend on port ${frontendPort}...`);
     const frontendEnv = {
       ...baseEnv,
       NOEGO_SERVICE: 'frontend',
@@ -396,6 +498,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   const stopBackend = () =>
     new Promise((resolve) => {
       if (!backendProc) return resolve();
+      logger.info(`⏹️  Stopping backend (preparing for restart #${backendRestartCount + 1})...`);
       const to = setTimeout(resolve, 2000);
       backendProc.once('exit', () => {
         clearTimeout(to);
@@ -411,6 +514,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   const stopFrontend = () =>
     new Promise((resolve) => {
       if (!frontendProc) return resolve();
+      logger.info(`⏹️  Stopping frontend (preparing for restart #${frontendRestartCount + 1})...`);
       const to = setTimeout(resolve, 2000);
       frontendProc.once('exit', () => {
         clearTimeout(to);
@@ -422,32 +526,74 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
         resolve();
       }
     });
-  
+
+  async function shutdown(signal = 'SIGTERM', exitCode = 0) {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    logger.info(`Shutting down split-serve processes (signal: ${signal})...`);
+
+    try {
+      if (watcher) {
+        await watcher.close();
+      }
+
+      await stopBackend();
+      await stopFrontend();
+
+      logger.info('All processes shut down successfully');
+    } catch (error) {
+      logger.error('Error during shutdown:', error);
+    }
+
+    process.exit(exitCode);
+  }
+
+  async function handleWatcherError(error) {
+    if (isShuttingDown) {
+      return;
+    }
+    logger.error('Watcher error:', error);
+    logger.error('File watching failed; shutting down dev server.');
+    await shutdown('watcherError', 1);
+  }
+
   const handleFileChange = async (reason, file) => {
     if (pending) return;
     pending = true;
-    
-    const absPath = path.isAbsolute(file) ? file : path.resolve(root, file);
-    
+
+    // With cwd set, chokidar reports relative paths
+    // Our patterns are now relative, so match against the relative path
+    const relativePath = path.isAbsolute(file) ? path.relative(root, file) : file;
+
     // Determine which service(s) to restart
     let restartBackend = false;
     let restartFrontend = false;
-    
-    if (sharedMatcher && sharedMatcher(absPath)) {
+
+    if (sharedMatcher && sharedMatcher(relativePath)) {
       // Shared file changed - restart both
-      logger.info(`Shared file changed (${reason}): ${file}`);
+      logger.info(`\n${'='.repeat(80)}`);
+      logger.info(`🔄 FILE CHANGE DETECTED: ${relativePath} (${reason})`);
+      logger.info(`   Type: SHARED - Will restart BOTH backend and frontend`);
+      logger.info('='.repeat(80));
       restartBackend = true;
       restartFrontend = true;
-    } else if (backendMatcher && backendMatcher(absPath)) {
+    } else if (backendMatcher && backendMatcher(relativePath)) {
       // Backend file changed
-      logger.info(`Backend file changed (${reason}): ${file}`);
+      logger.info(`\n${'='.repeat(80)}`);
+      logger.info(`🔄 FILE CHANGE DETECTED: ${relativePath} (${reason})`);
+      logger.info(`   Type: BACKEND - Will restart backend only`);
+      logger.info('='.repeat(80));
       restartBackend = true;
-    } else if (frontendMatcher && frontendMatcher(absPath)) {
+    } else if (frontendMatcher && frontendMatcher(relativePath)) {
       // Frontend file changed
-      logger.info(`Frontend file changed (${reason}): ${file}`);
+      logger.info(`\n${'='.repeat(80)}`);
+      logger.info(`🔄 FILE CHANGE DETECTED: ${relativePath} (${reason})`);
+      logger.info(`   Type: FRONTEND - Will restart frontend only`);
+      logger.info('='.repeat(80));
       restartFrontend = true;
     }
-    
+
     // Restart appropriate service(s)
     if (restartBackend) {
       await stopBackend();
@@ -457,20 +603,51 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
       await stopFrontend();
       startFrontend();
     }
-    
+
+    if (restartBackend || restartFrontend) {
+      logger.info(`✅ Restart complete\n`);
+    }
+
     pending = false;
   };
   
   // Create watcher
-  const watcher = chokidar.watch(allPatterns, {
-    ignoreInitial: true,
-    cwd: root
-  });
-  
+  // Use cwd with relative patterns for proper glob support
+  logger.info(`[WATCHER] Creating watcher with cwd: ${root}`);
+  logger.info(`[WATCHER] Patterns (classification only): ${JSON.stringify(allPatterns, null, 2)}`);
+  logger.info(`[WATCHER] Concrete targets: ${JSON.stringify(Array.from(watchTargets), null, 2)}`);
+
+  let watcher;
+  try {
+    watcher = chokidar.watch(Array.from(watchTargets), {
+      cwd: root,
+      ignoreInitial: true
+    });
+  } catch (error) {
+    await handleWatcherError(error);
+    return;
+  }
+
+  // Debug: Log what patterns we're actually watching
+  logger.info('Watch patterns:', allPatterns);
+
   watcher
-    .on('add', (p) => handleFileChange('add', p))
-    .on('change', (p) => handleFileChange('change', p))
-    .on('unlink', (p) => handleFileChange('unlink', p));
+    .on('add', (p) => {
+      logger.info(`[WATCHER] File add event: ${p}`);
+      handleFileChange('add', p);
+    })
+    .on('change', (p) => {
+      logger.info(`[WATCHER] File change event: ${p}`);
+      handleFileChange('change', p);
+    })
+    .on('unlink', (p) => {
+      logger.info(`[WATCHER] File unlink event: ${p}`);
+      handleFileChange('unlink', p);
+    })
+    .on('ready', () => {
+      logger.info('File watcher is ready');
+    })
+    .on('error', handleWatcherError);
   
   // Start initial processes
   startBackend();
@@ -497,17 +674,38 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   // Use dynamic import instead of require for ES module compatibility
   await import(runtimeEntryPath);
 
-  // Handle shutdown
-  const shutdown = async () => {
-    logger.info('Shutting down split-serve processes...');
-    await stopBackend();
-    await stopFrontend();
-    await watcher.close();
-    process.exit(0);
-  };
-  
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
+  // Handle graceful shutdown signals
+  process.on('SIGINT', () => shutdown('SIGINT', 0));
+  process.on('SIGTERM', () => shutdown('SIGTERM', 0));
+
+  // Handle process exit - this ensures children are killed even if parent crashes
+  process.on('exit', () => {
+    // Synchronous cleanup only - exit event doesn't allow async
+    // Kill entire process tree (including tsx wrappers and their children)
+    if (backendProc && backendProc.pid && !backendProc.killed) {
+      killProcessTree(backendProc.pid);
+    }
+    if (frontendProc && frontendProc.pid && !frontendProc.killed) {
+      killProcessTree(frontendProc.pid);
+    }
+  });
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', async (error) => {
+    logger.error('Uncaught exception:', error);
+    await shutdown('uncaughtException', 1);
+  });
+
+  // Handle unhandled promise rejections
+  process.on('unhandledRejection', async (reason, promise) => {
+    logger.error('Unhandled rejection at:', promise, 'reason:', reason);
+    await shutdown('unhandledRejection', 1);
+  });
+
+  // Keep process alive for file watching
+  // This promise never resolves, keeping the event loop running
+  // The process will only exit via the signal handlers above
+  await new Promise(() => {});
 }
 
 async function createWatcher(context, yamlConfig, configFilePath) {
@@ -518,49 +716,75 @@ async function createWatcher(context, yamlConfig, configFilePath) {
   const chokidar = requireFromRoot('chokidar');
   
   const patterns = new Set();
-  
-  const resolvePattern = (pattern) => {
-    if (path.isAbsolute(pattern)) return pattern;
-    return path.resolve(root, pattern);
+
+  // Keep patterns relative for chokidar to work properly with globs
+  const normalizePattern = (pattern) => {
+    // If pattern is absolute, make it relative to root
+    if (path.isAbsolute(pattern)) {
+      return path.relative(root, pattern);
+    }
+    return pattern;
   };
-  
-  // User-supplied watch paths
-  if (yamlConfig.dev?.watchPaths) {
-    for (const pattern of yamlConfig.dev.watchPaths) {
-      patterns.add(resolvePattern(pattern));
+
+  // App watch patterns
+  if (yamlConfig.app?.watch) {
+    for (const pattern of yamlConfig.app.watch) {
+      patterns.add(normalizePattern(pattern));
     }
   }
-  
-  // Default watch patterns from config
-  if (yamlConfig.server?.controllers) {
-    patterns.add(resolvePattern(`${yamlConfig.server.controllers}/**/*.{ts,js}`));
-  }
-  if (yamlConfig.server?.middleware) {
-    patterns.add(resolvePattern(`${yamlConfig.server.middleware}/**/*.{ts,js}`));
+
+  // Server watch patterns
+  if (yamlConfig.server?.watch) {
+    for (const pattern of yamlConfig.server.watch) {
+      patterns.add(normalizePattern(pattern));
+    }
   }
-  if (yamlConfig.server?.openapi) {
-    patterns.add(resolvePattern(yamlConfig.server.openapi));
-    const openapiDir = path.dirname(resolvePattern(yamlConfig.server.openapi));
-    patterns.add(path.join(openapiDir, 'openapi/**/*.yaml'));
+
+  // Client watch patterns
+  if (yamlConfig.client?.watch) {
+    for (const pattern of yamlConfig.client.watch) {
+      patterns.add(normalizePattern(pattern));
+    }
   }
-  if (yamlConfig.client?.openapi) {
-    patterns.add(resolvePattern(yamlConfig.client.openapi));
-    const openapiDir = path.dirname(resolvePattern(yamlConfig.client.openapi));
-    patterns.add(path.join(openapiDir, 'openapi/**/*.yaml'));
+
+  if (patterns.size === 0) {
+    logger.warn('No watch patterns configured. Watching disabled.');
+    return null;
   }
-  if (yamlConfig.assets) {
-    for (const asset of yamlConfig.assets) {
-      if (asset.includes('*.sql')) {
-        patterns.add(resolvePattern(asset));
-      }
+
+  // Convert patterns to concrete watch targets (directories/files)
+  const GLOB_CHARS = /[\\*?\[\]\{\}\(\)!+@]/;
+  const watchTargets = new Set();
+  for (const p of patterns) {
+    const isGlob = GLOB_CHARS.test(p);
+    if (!isGlob) {
+      watchTargets.add(p);
+    } else {
+      const base = globParent(p);
+      watchTargets.add(base && base.length > 0 ? base : '.');
     }
   }
-  
+
   logger.info('Watching for changes to restart server...');
-  const watcher = chokidar.watch(Array.from(patterns), {
-    ignoreInitial: true,
-    cwd: root
+  logger.info(`[WATCHER] Concrete targets: ${JSON.stringify(Array.from(watchTargets), null, 2)}`);
+  // Use cwd with relative targets for proper glob support
+  let watcher;
+  try {
+    watcher = chokidar.watch(Array.from(watchTargets), {
+      cwd: root,
+      ignoreInitial: true
+    });
+  } catch (error) {
+    logger.error('Failed to start file watcher:', error);
+    throw error;
+  }
+
+  watcher.on('error', (error) => {
+    logger.error('Watcher error:', error);
+    logger.error('File watching is required for dev mode; exiting.');
+    process.exit(1);
   });
+
   return watcher;
 }
 
@@ -604,19 +828,23 @@ async function runWithRestart(context, tsxExecutable, tsxArgs, env, watcher, log
     start();
     pending = false;
   };
-  
-  watcher
-    .on('add', (p) => scheduleRestart('add', p))
-    .on('change', (p) => scheduleRestart('change', p))
-    .on('unlink', (p) => scheduleRestart('unlink', p));
-  
+
+  if (watcher) {
+    watcher
+      .on('add', (p) => scheduleRestart('add', p))
+      .on('change', (p) => scheduleRestart('change', p))
+      .on('unlink', (p) => scheduleRestart('unlink', p));
+  }
+
   // Start initial server
   start();
-  
+
   // Keep process alive until SIGINT/SIGTERM
   const shutdown = async () => {
     await stop();
-    await watcher.close();
+    if (watcher) {
+      await watcher.close();
+    }
     process.exit(0);
   };
   process.on('SIGINT', shutdown);

package/src/commands/serve.js

@@ -74,39 +74,52 @@ async function createWatcher(context) {
     patterns.add(value);
   };
 
-  const resolveGlob = (entry) => {
+  // Keep patterns relative for chokidar to work properly with globs
+  const normalizePattern = (entry) => {
     if (!entry) return null;
     if (typeof entry === 'string') {
-      return path.isAbsolute(entry) ? entry : path.join(config.rootDir, entry);
+      // If pattern is absolute, make it relative to rootDir
+      if (path.isAbsolute(entry)) {
+        return path.relative(config.rootDir, entry);
+      }
+      return entry;
     }
+    // Handle object-style patterns
     if (entry.isAbsolute) {
-      return entry.pattern;
+      return path.relative(config.rootDir, entry.pattern);
     }
     if (entry.cwd) {
-      return path.join(entry.cwd, entry.pattern);
+      const absolute = path.join(entry.cwd, entry.pattern);
+      return path.relative(config.rootDir, absolute);
     }
     return entry.pattern;
   };
 
-  // User-supplied patterns
-  for (const entry of config.dev.watchPaths) {
-    const pattern = resolveGlob(entry);
-    if (pattern) addPattern(pattern);
+  // App watch patterns - restart server
+  if (config.app?.watch) {
+    for (const entry of config.app.watch) {
+      const pattern = normalizePattern(entry);
+      if (pattern) addPattern(pattern);
+    }
   }
 
-  // Server-side defaults
-  addPattern(path.join(config.server.controllersDir, '**/*.{ts,js}'));
-  addPattern(path.join(config.server.middlewareDir, '**/*.{ts,js}'));
-  addPattern(config.server.openapiFile);
-  addPattern(path.join(path.dirname(config.server.openapiFile), 'openapi/**/*.yaml'));
-  for (const entry of config.server.sqlGlobs) {
-    const pattern = resolveGlob(entry);
-    if (pattern) addPattern(pattern);
+  // Server watch patterns - restart server
+  if (config.server?.watch) {
+    for (const entry of config.server.watch) {
+      const pattern = normalizePattern(entry);
+      if (pattern) addPattern(pattern);
+    }
   }
 
-  // UI OpenAPI changes should restart (routes/manifest)
-  addPattern(config.ui.openapiFile);
-  addPattern(path.join(path.dirname(config.ui.openapiFile), 'openapi/**/*.yaml'));
+  // Client watch patterns - restart server (in non-split mode)
+  // Check both ui.watch (from buildConfig) and client.watch (from spread)
+  const clientWatch = config.ui?.watch || config.client?.watch;
+  if (clientWatch) {
+    for (const entry of clientWatch) {
+      const pattern = normalizePattern(entry);
+      if (pattern) addPattern(pattern);
+    }
+  }
 
   // Ignore Svelte/client files to let Vite HMR handle them
   const uiIgnores = [
@@ -114,11 +127,17 @@ async function createWatcher(context) {
     path.join(config.ui.rootDir, '**/*.{ts,tsx,css,scss,html}')
   ];
 
+  if (patterns.size === 0) {
+    logger.warn('No watch patterns configured. Watching disabled.');
+    return null;
+  }
+
   logger.info('Watching for changes to restart server...');
+  // Use cwd with relative patterns for proper glob support
   const watcher = chokidar.watch(Array.from(patterns), {
+    cwd: config.rootDir,
     ignoreInitial: true,
-    ignored: uiIgnores,
-    cwd: config.rootDir
+    ignored: uiIgnores
   });
   return watcher;
 }
@@ -166,10 +185,12 @@ async function runWithRestart(context, runner, watcher, frontendProc) {
     pending = false;
   };
 
-  watcher
-    .on('add', (p) => scheduleRestart('add', p))
-    .on('change', (p) => scheduleRestart('change', p))
-    .on('unlink', (p) => scheduleRestart('unlink', p));
+  if (watcher) {
+    watcher
+      .on('add', (p) => scheduleRestart('add', p))
+      .on('change', (p) => scheduleRestart('change', p))
+      .on('unlink', (p) => scheduleRestart('unlink', p));
+  }
 
   // Start initial server
   start();
@@ -177,7 +198,9 @@ async function runWithRestart(context, runner, watcher, frontendProc) {
   // Keep process alive until SIGINT/SIGTERM
   const shutdown = async () => {
     await stop();
-    await watcher.close();
+    if (watcher) {
+      await watcher.close();
+    }
     if (frontendProc) {
       try { frontendProc.kill('SIGTERM'); } catch {}
     }

package/src/config.js

@@ -73,7 +73,8 @@ export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } =
       controllersDir: config.server.controllers_abs,
       middlewareDir: config.server.middleware_abs,
       openapiFile: config.server.openapi_abs,
-      sqlGlobs: serverSqlGlobs
+      sqlGlobs: serverSqlGlobs,
+      watch: config.server.watch  // Preserve watch property
     } : null,
     ui: config.client ? {
       rootDir: uiRootDir,
@@ -85,7 +86,8 @@ export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } =
       options: {}, // This seems to be deprecated
       openapiFile: config.client.openapi_abs,
       assets: assetSpecs,
-      clientExclude: clientExcludeSpecs
+      clientExclude: clientExcludeSpecs,
+      watch: config.client.watch  // Preserve watch property
     } : null,
     assets: assetSpecs,
     vite: {

package/src/runtime/config.js

@@ -0,0 +1,82 @@
+import path from 'node:path';
+import { loadConfig, findConfigFile, loadConfigFromEnv } from './config-loader.js';
+import {setContext} from "../client";
+
+
+
+
+/**
+ * Loads and applies the resolved project configuration to the application's runtime context.
+ * 
+ * @param {(config:any) => any} getAppFunction - A function that returns the application instance (e.g., Express app).
+ * @returns {Promise<object>} - The fully resolved and normalized configuration object.
+ */
+export async function buildConfig(getAppFunction) {
+  // Retrieve the application instance from the provided function.
+  /** @type {any} */
+  const app = getAppFunction();
+  // Load and resolve the configuration via getConfig (auto-detects config file or env).
+  const { config } = await getConfig();
+  // Attach the loaded config to the runtime context for downstream usage.
+  setContext(app, config);
+  // Return the config for consumers (generates env and internal path invariants).
+  return {config,app};
+}
+
+/**
+ * Automatically load configuration from environment variable or config file.
+ * 
+ * This function:
+ * 1. First checks NOEGO_CONFIGURATION env var (uses loadConfigFromEnv if present)
+ * 2. Otherwise searches for config file starting from rootDir (or process.cwd())
+ *    and walks up directories until a config file is found
+ * 3. Sets all environment variables automatically
+ * 4. Returns the fully resolved config object
+ * 
+ * @param {string} [rootDir] - Optional starting directory for config file search. Defaults to process.cwd()
+ * @returns {Promise<{root: string, config: object, configFilePath: string|null}>}
+ */
+export async function getConfig(rootDir) {
+  // First priority: check NOEGO_CONFIGURATION env var
+  if (process.env.NOEGO_CONFIGURATION) {
+    return loadConfigFromEnv();
+  }
+
+  // Second priority: find and load config file
+  const startDir = rootDir ? path.resolve(rootDir) : process.cwd();
+
+  
+  // Walk up directories to find config file
+  let currentDir = startDir;
+  let lastDir = '';
+  
+  while (currentDir !== lastDir) {
+    try {
+      const configFilePath = await findConfigFile(currentDir);
+      // Found config file, load it
+      // Pass rootDir if provided, otherwise let loadConfig determine root from config file
+      return await loadConfig(configFilePath, rootDir);
+    } catch (error) {
+      // Config file not found in this directory, try parent
+      lastDir = currentDir;
+      currentDir = path.dirname(currentDir);
+      
+      // Stop if we've reached filesystem root
+      if (currentDir === lastDir) {
+        throw new Error(
+          `No configuration file found starting from ${startDir}.\n` +
+          `Please create hammer.config.yml (or a similar named file) in your project root.`
+        );
+      }
+    }
+  }
+
+  
+  
+  // Should never reach here, but just in case
+  throw new Error(
+    `No configuration file found starting from ${startDir}.\n` +
+    `Please create hammer.config.yml (or a similar named file) in your project root.`
+  );
+}
+

package/types/config.d.ts

@@ -0,0 +1,23 @@
+import type { Express } from 'express';
+
+/**
+ * Result returned by buildConfig
+ */
+export interface BuildConfigResult {
+  config: Record<string, unknown>;
+  app: Express;
+}
+
+/**
+ * Loads and applies the resolved project configuration to the application's runtime context.
+ * 
+ * This function:
+ * 1. Retrieves the application instance from the provided function
+ * 2. Loads configuration via getConfig (auto-detects config file or env)
+ * 3. Attaches the loaded config to the runtime context via setContext
+ * 4. Returns both the config object and app instance for consumers
+ * 
+ * @param getAppFunction - A function that returns the application instance (e.g., Express app)
+ * @returns Promise resolving to an object containing both the config and app
+ */
+export function buildConfig(getAppFunction: (config:any) => Express): Promise<BuildConfigResult>;