@noego/app 0.0.7 → 0.0.9

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.7",
+  "version": "0.0.9",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {
@@ -29,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"
@@ -38,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,7 +357,9 @@ 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;
@@ -301,8 +369,11 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   const normalizePattern = (pattern) => {
     // If pattern is absolute, make it relative to root
     if (path.isAbsolute(pattern)) {
-      return path.relative(root, pattern);
+      const normalized = path.relative(root, pattern);
+      logger.debug(`Normalized pattern: ${pattern} -> ${normalized}`);
+      return normalized;
     }
+    logger.debug(`Pattern already relative: ${pattern}`);
     return pattern;
   };
 
@@ -332,8 +403,28 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
     }
   }
   
-  // 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.');
@@ -344,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',
@@ -377,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',
@@ -401,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);
@@ -416,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);
@@ -427,7 +526,38 @@ 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;
@@ -442,19 +572,28 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
 
     if (sharedMatcher && sharedMatcher(relativePath)) {
       // Shared file changed - restart both
-      logger.info(`Shared file changed (${reason}): ${relativePath}`);
+      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(relativePath)) {
       // Backend file changed
-      logger.info(`Backend file changed (${reason}): ${relativePath}`);
+      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(relativePath)) {
       // Frontend file changed
-      logger.info(`Frontend file changed (${reason}): ${relativePath}`);
+      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();
@@ -464,39 +603,51 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
       await stopFrontend();
       startFrontend();
     }
-    
+
+    if (restartBackend || restartFrontend) {
+      logger.info(`✅ Restart complete\n`);
+    }
+
     pending = false;
   };
   
   // Create watcher
   // Use cwd with relative patterns for proper glob support
-  const watcher = chokidar.watch(allPatterns, {
-    cwd: root,
-    ignoreInitial: true
-  });
+  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) => {
-      logger.debug(`File add event: ${p}`);
+      logger.info(`[WATCHER] File add event: ${p}`);
       handleFileChange('add', p);
     })
     .on('change', (p) => {
-      logger.debug(`File change event: ${p}`);
+      logger.info(`[WATCHER] File change event: ${p}`);
       handleFileChange('change', p);
     })
     .on('unlink', (p) => {
-      logger.debug(`File unlink event: ${p}`);
+      logger.info(`[WATCHER] File unlink event: ${p}`);
       handleFileChange('unlink', p);
     })
     .on('ready', () => {
       logger.info('File watcher is ready');
     })
-    .on('error', (error) => {
-      logger.error('Watcher error:', error);
-    });
+    .on('error', handleWatcherError);
   
   // Start initial processes
   startBackend();
@@ -523,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) {
@@ -580,12 +752,39 @@ async function createWatcher(context, yamlConfig, configFilePath) {
     return null;
   }
 
+  // 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...');
-  // Use cwd with relative patterns for proper glob support
-  const watcher = chokidar.watch(Array.from(patterns), {
-    cwd: root,
-    ignoreInitial: true
+  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;
 }