@noego/app 0.0.11 → 0.0.12

package/.claude/settings.local.json

@@ -0,0 +1,17 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cat:*)",
+      "Bash(curl:*)",
+      "Bash(noego dev)",
+      "WebSearch",
+      "WebFetch(domain:mattkentzia.com)",
+      "Bash(node --test:*)",
+      "WebFetch(domain:svelte.dev)",
+      "WebFetch(domain:github.com)",
+      "Bash(tree:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/app",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {

package/src/args.js

@@ -27,11 +27,17 @@ const FLAG_MAP = new Map([
   ['mode', 'mode'],
   ['verbose', 'verbose'],
   ['help', 'help'],
-  ['version', 'version']
+  ['version', 'version'],
+  ['ci-server', 'testServer'],
+  ['ci-test', 'testCommand'],
+  ['ci-status', 'testStatus'],
+  ['ci-port', 'testPort'],
+  ['ci-timeout', 'testTimeout'],
+  ['ci-visible', 'testVisible']
 ]);
 
 const MULTI_VALUE_FLAGS = new Set(['sqlGlob', 'assets', 'clientExclude', 'watchPath']);
-const BOOLEAN_FLAGS = new Set(['watch', 'splitServe', 'verbose']);
+const BOOLEAN_FLAGS = new Set(['watch', 'splitServe', 'verbose', 'testVisible']);
 
 export function parseCliArgs(argv) {
   const result = {
@@ -129,6 +135,15 @@ export function printHelpAndExit({ stdout = process.stdout } = {}) {
   app dev [options]
   app serve [options]
   app preview [options]
+  app ci [options]
+
+CI Testing Options:
+  --ci-server <cmd>       Server start command (default: npm run dev)
+  --ci-test <cmd>         Test command (default: npm run test:live)
+  --ci-status <path>      Health check endpoint (default: /api/status)
+  --ci-port <number>      Server port (default: random 4000-8000)
+  --ci-timeout <seconds>  Health check timeout (default: 60)
+  --ci-visible            Run browser in visible mode
 
 Options (shared):
   --root <dir>            Project root (default: .)

package/src/cli.js

@@ -8,6 +8,7 @@ import { runBuild } from './commands/build.js';
 import { runServe } from './commands/serve.js';
 import { runPreview } from './commands/preview.js';
 import { runDev } from './commands/dev.js';
+import { runTestLive } from './commands/test-live.js';
 
 export async function runCli(argv = process.argv.slice(2)) {
   try {
@@ -43,6 +44,11 @@ export async function runCli(argv = process.argv.slice(2)) {
         await runPreview(config);
         break;
       }
+      case 'ci': {
+        const config = await loadBuildConfig(options, { cwd: process.cwd() });
+        await runTestLive(config);
+        break;
+      }
       default:
         throw cliError(`Unknown command "${command}"`);
     }

package/src/commands/dev.js

@@ -449,52 +449,115 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   let frontendRestartCount = 0;
   let isShuttingDown = false;
 
+  // Crash restart tracking
+  const MAX_CRASH_RESTARTS = 3;
+  const CRASH_RESTART_DELAY = 2000; // 2 seconds between crash restarts
+  const STABILITY_THRESHOLD = 30000; // Reset crash counter if running 30+ seconds
+  let backendCrashRestarts = 0;
+  let frontendCrashRestarts = 0;
+  let backendStartTime = 0;
+  let frontendStartTime = 0;
+
   const startBackend = () => {
     backendRestartCount++;
+    backendStartTime = Date.now();
     logger.info(`🚀 [RESTART #${backendRestartCount}] Starting backend on port ${backendPort}...`);
     const backendEnv = {
       ...baseEnv,
       NOEGO_SERVICE: 'backend',
       NOEGO_PORT: String(backendPort)
     };
-    
+
     backendProc = spawn(tsxExecutable, tsxArgs, {
       cwd: context.config.rootDir,
       env: backendEnv,
       stdio: 'inherit',
       detached: false
     });
-    
-    backendProc.on('exit', (code) => {
+
+    backendProc.on('exit', (code, signal) => {
+      if (isShuttingDown) return;
+
+      // Check if process was stable (ran for a while) - reset crash counter
+      const runDuration = Date.now() - backendStartTime;
+      if (runDuration > STABILITY_THRESHOLD) {
+        backendCrashRestarts = 0;
+      }
+
       if (code !== null && code !== 0) {
-        logger.error(`Backend exited with code ${code}`);
+        logger.error(`[BACKEND] Exited with code ${code}, signal ${signal}`);
+
+        // Auto-restart on crash if under limit
+        if (backendCrashRestarts < MAX_CRASH_RESTARTS) {
+          backendCrashRestarts++;
+          logger.warn(`[BACKEND] Crash detected. Auto-restart ${backendCrashRestarts}/${MAX_CRASH_RESTARTS} in ${CRASH_RESTART_DELAY}ms...`);
+          setTimeout(() => {
+            if (!isShuttingDown) {
+              startBackend();
+            }
+          }, CRASH_RESTART_DELAY);
+        } else {
+          logger.error(`[BACKEND] Exceeded max crash restarts (${MAX_CRASH_RESTARTS}). Shutting down...`);
+          shutdown('backend-exceeded-restarts', 1, 'backend-crash');
+        }
       }
     });
+
+    backendProc.on('error', (err) => {
+      logger.error(`[BACKEND] Spawn error: ${err.message}`);
+    });
   };
-  
+
   const startFrontend = () => {
     frontendRestartCount++;
+    frontendStartTime = Date.now();
     logger.info(`🚀 [RESTART #${frontendRestartCount}] Starting frontend on port ${frontendPort}...`);
     const frontendEnv = {
       ...baseEnv,
       NOEGO_SERVICE: 'frontend',
       NOEGO_PORT: String(frontendPort)
     };
-    
+
     frontendProc = spawn(tsxExecutable, tsxArgs, {
       cwd: context.config.rootDir,
       env: frontendEnv,
       stdio: 'inherit',
       detached: false
     });
-    
-    frontendProc.on('exit', (code) => {
+
+    frontendProc.on('exit', (code, signal) => {
+      if (isShuttingDown) return;
+
+      // Check if process was stable (ran for a while) - reset crash counter
+      const runDuration = Date.now() - frontendStartTime;
+      if (runDuration > STABILITY_THRESHOLD) {
+        frontendCrashRestarts = 0;
+      }
+
       if (code !== null && code !== 0) {
-        logger.error(`Frontend exited with code ${code}`);
+        logger.error(`[FRONTEND] Exited with code ${code}, signal ${signal}`);
+
+        // Auto-restart on crash if under limit
+        if (frontendCrashRestarts < MAX_CRASH_RESTARTS) {
+          frontendCrashRestarts++;
+          logger.warn(`[FRONTEND] Crash detected. Auto-restart ${frontendCrashRestarts}/${MAX_CRASH_RESTARTS} in ${CRASH_RESTART_DELAY}ms...`);
+          setTimeout(() => {
+            if (!isShuttingDown) {
+              startFrontend();
+            }
+          }, CRASH_RESTART_DELAY);
+        } else {
+          logger.error(`[FRONTEND] Exceeded max crash restarts (${MAX_CRASH_RESTARTS}). Shutting down...`);
+          shutdown('frontend-exceeded-restarts', 1, 'frontend-crash');
+        }
       }
     });
+
+    frontendProc.on('error', (err) => {
+      logger.error(`[FRONTEND] Spawn error: ${err.message}`);
+    });
   };
-  
+
   const stopBackend = () =>
     new Promise((resolve) => {
       if (!backendProc) return resolve();
@@ -549,10 +612,11 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
       }
     });
 
-  async function shutdown(signal = 'SIGTERM', exitCode = 0) {
+  async function shutdown(signal = 'SIGTERM', exitCode = 0, source = 'unknown') {
     if (isShuttingDown) return;
     isShuttingDown = true;
 
+    logger.info(`[SHUTDOWN] source=${source}, signal=${signal}, exitCode=${exitCode}`);
     logger.info(`Shutting down split-serve processes (signal: ${signal})...`);
 
     try {
@@ -577,7 +641,7 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
     }
     logger.error('Watcher error:', error);
     logger.error('File watching failed; shutting down dev server.');
-    await shutdown('watcherError', 1);
+    await shutdown('watcherError', 1, 'watcher-error');
   }
 
   const handleFileChange = async (reason, file) => {
@@ -699,8 +763,8 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   await import(runtimeEntryPath);
 
   // Handle graceful shutdown signals
-  process.on('SIGINT', () => shutdown('SIGINT', 0));
-  process.on('SIGTERM', () => shutdown('SIGTERM', 0));
+  process.on('SIGINT', () => shutdown('SIGINT', 0, 'signal-handler'));
+  process.on('SIGTERM', () => shutdown('SIGTERM', 0, 'signal-handler'));
 
   // Handle process exit - this ensures children are killed even if parent crashes
   process.on('exit', () => {
@@ -717,13 +781,13 @@ async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv,
   // Handle uncaught exceptions
   process.on('uncaughtException', async (error) => {
     logger.error('Uncaught exception:', error);
-    await shutdown('uncaughtException', 1);
+    await shutdown('uncaughtException', 1, 'uncaught-exception');
   });
 
   // Handle unhandled promise rejections
   process.on('unhandledRejection', async (reason, promise) => {
     logger.error('Unhandled rejection at:', promise, 'reason:', reason);
-    await shutdown('unhandledRejection', 1);
+    await shutdown('unhandledRejection', 1, 'unhandled-rejection');
   });
 
   // Keep process alive for file watching

package/src/commands/test-live.js

@@ -0,0 +1,187 @@
+import { spawn } from 'child_process';
+import { createBuildContext } from '../build/context.js';
+
+/**
+ * Polls health check endpoint until server is ready
+ */
+async function waitForServer(port, statusPath, timeoutSec, logger) {
+  const url = `http://localhost:${port}${statusPath}`;
+  const maxAttempts = timeoutSec;
+
+  logger.info(`Waiting for server at ${url}...`);
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(2000) });
+
+      if (response.ok) {
+        const data = await response.json();
+
+        // For /status/deep - check both status and database
+        if (statusPath.includes('deep')) {
+          if (data.status === 'OK' && data.database === 'connected') {
+            logger.info('Server is ready!');
+            await new Promise(r => setTimeout(r, 2000)); // Extra 2s for full init
+            return true;
+          }
+        } else if (data.status === 'OK' || data.status === 'ok') {
+          logger.info('Server is ready!');
+          await new Promise(r => setTimeout(r, 2000));
+          return true;
+        }
+      }
+    } catch (err) {
+      // Connection refused or timeout - server not ready yet
+    }
+
+    if (attempt < maxAttempts) {
+      await new Promise(r => setTimeout(r, 1000)); // Wait 1s between attempts
+      if (attempt % 5 === 0) {
+        logger.info(`Still waiting... (${attempt}/${maxAttempts})`);
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Spawns a command and returns a process handle
+ */
+function spawnCommand(command, env, logger) {
+  logger.info(`Spawning: ${command}`);
+
+  const child = spawn(command, {
+    shell: true,
+    stdio: 'inherit',
+    env: { ...process.env, ...env },
+    detached: process.platform !== 'win32', // Process group for Unix
+  });
+
+  return child;
+}
+
+/**
+ * Kills process tree (cross-platform)
+ */
+function killProcessTree(pid, logger) {
+  try {
+    if (process.platform === 'win32') {
+      spawn('taskkill', ['/pid', pid.toString(), '/T', '/F'], { stdio: 'ignore' });
+    } else {
+      process.kill(-pid, 'SIGKILL'); // Negative PID kills process group
+    }
+  } catch (err) {
+    logger.debug(`Process ${pid} already terminated`);
+  }
+}
+
+/**
+ * Main test:live command implementation
+ */
+export async function runTestLive(config) {
+  const context = createBuildContext(config);
+  const { logger } = context;
+
+  // Parse options - no defaults, must be specified
+  const serverCmd = config.testServer;
+  const testCmd = config.testCommand;
+  const statusPath = config.testStatus;
+  const port = config.testPort || Math.floor(Math.random() * 4000) + 4000;
+  const timeout = config.testTimeout || 60;
+  const visible = config.testVisible || false;
+
+  // Validate required options
+  if (!serverCmd) {
+    logger.error('❌ Missing required option: --ci-server');
+    logger.info('Example: noego ci --ci-server "npm run dev" --ci-test "npm run test:live" --ci-status "/api/status"');
+    process.exit(1);
+  }
+
+  if (!testCmd) {
+    logger.error('❌ Missing required option: --ci-test');
+    logger.info('Example: noego ci --ci-server "npm run dev" --ci-test "npm run test:live" --ci-status "/api/status"');
+    process.exit(1);
+  }
+
+  if (!statusPath) {
+    logger.error('❌ Missing required option: --ci-status');
+    logger.info('Example: noego ci --ci-server "npm run dev" --ci-test "npm run test:live" --ci-status "/api/status"');
+    process.exit(1);
+  }
+
+  logger.info('🧪 Live Test Runner');
+  logger.info(`   Server: ${serverCmd}`);
+  logger.info(`   Tests: ${testCmd}`);
+  logger.info(`   Port: ${port}`);
+  logger.info(`   Health: ${statusPath}`);
+
+  let serverProcess = null;
+  let exitCode = 1;
+
+  const cleanup = async () => {
+    if (serverProcess && !serverProcess.killed) {
+      logger.info('Shutting down server...');
+      killProcessTree(serverProcess.pid, logger);
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  };
+
+  // Handle interrupts
+  process.on('SIGINT', async () => {
+    logger.info('Interrupted by user');
+    await cleanup();
+    process.exit(130);
+  });
+
+  process.on('SIGTERM', async () => {
+    await cleanup();
+    process.exit(143);
+  });
+
+  try {
+    // Start server
+    serverProcess = spawnCommand(serverCmd, { PORT: port.toString() }, logger);
+
+    // Wait for health check
+    logger.info('Waiting for server to be ready...');
+    const ready = await waitForServer(port, statusPath, timeout, logger);
+
+    if (!ready) {
+      logger.error(`❌ Server failed to become healthy within ${timeout} seconds`);
+      await cleanup();
+      process.exit(1);
+    }
+
+    // Run tests
+    logger.info('✅ Server ready, running tests...');
+    const testEnv = {
+      PORT: port.toString(),
+      HEADLESS: visible ? 'false' : 'true',
+    };
+
+    const testProcess = spawnCommand(testCmd, testEnv, logger);
+
+    // Wait for tests to complete
+    exitCode = await new Promise((resolve) => {
+      testProcess.on('exit', (code) => resolve(code || 0));
+    });
+
+    if (exitCode === 0) {
+      logger.info('✅ Tests passed!');
+    } else {
+      logger.error(`❌ Tests failed with exit code ${exitCode}`);
+    }
+
+  } catch (err) {
+    logger.error('Test runner failed:', err.message);
+    if (err.stack) {
+      logger.debug(err.stack);
+    }
+    exitCode = 1;
+
+  } finally {
+    await cleanup();
+    process.exit(exitCode);
+  }
+}

package/src/config.js

@@ -71,6 +71,13 @@ export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } =
     ...config,
     rootDir: config.root,
     verbose: cliOptions.verbose || false,
+    // CI test options from CLI
+    testServer: cliOptions.testServer,
+    testCommand: cliOptions.testCommand,
+    testStatus: cliOptions.testStatus,
+    testPort: cliOptions.testPort,
+    testTimeout: cliOptions.testTimeout,
+    testVisible: cliOptions.testVisible,
     layout,
     server: config.server ? {
       rootDir: config.server.main_abs ? path.dirname(config.server.main_abs) : config.root,

package/src/runtime/runtime.js

@@ -97,12 +97,15 @@ async function setupProxyFirst(app, backendPort, config) {
         return resolve(cached.canHandle);
       }
 
+      // Configurable timeout - default 500ms is enough for GC pauses and startup
+      const checkTimeout = parseInt(process.env.NOEGO_BACKEND_CHECK_TIMEOUT) || 500;
+
       const options = {
         hostname: 'localhost',
         port: backendPort,
         path: pathname,
         method: 'GET',  // Use GET instead of HEAD since some backends don't support HEAD
-        timeout: 50,  // Very short timeout for dev mode
+        timeout: checkTimeout,
         headers: {
           'X-Proxy-Check': 'true'  // Indicate this is just a check
         }