@noego/app 0.0.2 → 0.0.4

package/src/runtime/runtime.js

@@ -0,0 +1,749 @@
+import path from 'node:path';
+import http from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { loadConfig } from './config-loader.js';
+import { setContext } from '../client.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function toFileUrl(filePath) {
+  return `file://${filePath}`;
+}
+
+function parseCookieHeader(header) {
+  const cookies = Object.create(null);
+  if (typeof header !== 'string' || header.length === 0) {
+    return cookies;
+  }
+
+  const segments = header.split(';');
+  for (const segment of segments) {
+    if (!segment) continue;
+    const separatorIndex = segment.indexOf('=');
+    if (separatorIndex === -1) continue;
+
+    const name = segment.slice(0, separatorIndex).trim();
+    if (!name) continue;
+
+    const rawValue = segment.slice(separatorIndex + 1).trim();
+    if (!rawValue) {
+      cookies[name] = '';
+      continue;
+    }
+
+    try {
+      cookies[name] = decodeURIComponent(rawValue);
+    } catch {
+      cookies[name] = rawValue;
+    }
+  }
+
+  return cookies;
+}
+
+function attachCookiePolyfill(app) {
+  if (!app || typeof app.use !== 'function') {
+    return;
+  }
+
+  app.use((req, res, next) => {
+    try {
+      if (req && (req.cookies == null) && req.headers && typeof req.headers.cookie === 'string') {
+        req.cookies = parseCookieHeader(req.headers.cookie);
+      }
+    } catch {
+      // Ignore cookie parsing errors; leave req.cookies undefined.
+    }
+    next();
+  });
+}
+
+/**
+ * Setup proxy middleware that runs BEFORE Vite/Forge
+ * This dynamically checks if the backend can handle each route
+ */
+async function setupProxyFirst(app, backendPort, config) {
+  try {
+    const { createRequire } = await import('node:module');
+    const requireFromRoot = createRequire(path.join(config.root, 'package.json'));
+    const http = await import('http');
+
+    // Cache backend route availability to avoid repeated HEAD requests
+    const routeCache = new Map();
+    const CACHE_TTL = 60000; // Cache for 60 seconds in dev mode
+
+    // Patterns that should NOT be proxied (frontend assets)
+    const isFrontendAsset = (pathname) => {
+      return (
+        pathname.startsWith('/@') ||  // Vite internals
+        pathname.startsWith('/node_modules') ||
+        pathname.startsWith('/src') ||
+        pathname.includes('.hot-update.') ||
+        // Static file extensions
+        /\.(js|mjs|jsx|ts|tsx|css|scss|sass|less|json|xml|html|htm|vue|svelte)$/.test(pathname) ||
+        /\.(png|jpg|jpeg|gif|svg|ico|webp|avif)$/.test(pathname) ||
+        /\.(woff|woff2|ttf|otf|eot)$/.test(pathname) ||
+        /\.(mp4|webm|ogg|mp3|wav|flac|aac)$/.test(pathname) ||
+        /\.(pdf|doc|docx|xls|xlsx|ppt|pptx|zip|tar|gz)$/.test(pathname)
+      );
+    };
+
+    // Check if backend can handle a route by making a HEAD request
+    const checkBackend = (pathname) => new Promise((resolve) => {
+      // Check cache first
+      const cached = routeCache.get(pathname);
+      if (cached && (Date.now() - cached.timestamp < CACHE_TTL)) {
+        return resolve(cached.canHandle);
+      }
+
+      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
+        headers: {
+          'X-Proxy-Check': 'true'  // Indicate this is just a check
+        }
+      };
+
+      const req = http.request(options, (res) => {
+        // If backend responds with anything other than 404, it can handle it
+        const canHandle = res.statusCode !== 404;
+        routeCache.set(pathname, { canHandle, timestamp: Date.now() });
+
+        // Immediately destroy the response to avoid consuming data
+        res.destroy();
+        resolve(canHandle);
+      });
+
+      req.on('error', () => {
+        // Backend not available or error
+        routeCache.set(pathname, { canHandle: false, timestamp: Date.now() });
+        resolve(false);
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        // On timeout, assume backend can't handle it
+        routeCache.set(pathname, { canHandle: false, timestamp: Date.now() });
+        resolve(false);
+      });
+
+      req.end();
+    });
+
+    try {
+      const { createProxyMiddleware } = requireFromRoot('http-proxy-middleware');
+
+      // Create proxy middleware
+      const proxyMiddleware = createProxyMiddleware({
+        target: `http://localhost:${backendPort}`,
+        changeOrigin: true,
+        ws: true,
+        logLevel: 'silent', // We'll do our own logging
+        onProxyReq: (proxyReq, req, res) => {
+          if (config.mode !== 'production') {
+            console.log(`[proxy] ${req.method} ${req.url} -> backend:${backendPort}`);
+          }
+        }
+      });
+
+      // Install selective proxy middleware that checks backend first
+      app.use(async (req, res, next) => {
+        const pathname = req.path || req.url || '';
+
+        // Skip if it's a frontend asset
+        if (isFrontendAsset(pathname)) {
+          return next();
+        }
+
+        // For non-asset paths, check if backend can handle it
+        try {
+          const backendCanHandle = await checkBackend(pathname);
+
+          if (backendCanHandle) {
+            // Backend can handle this route, proxy it
+            proxyMiddleware(req, res, next);
+          } else {
+            // Backend returned 404 or unavailable, let Vite/Forge handle it
+            next();
+          }
+        } catch (err) {
+          // On any error, fall back to Vite/Forge
+          console.error('[proxy] Error checking backend:', err);
+          next();
+        }
+      });
+
+      console.log(`[app] Dynamic proxy configured: checking backend at http://localhost:${backendPort} for non-asset routes`);
+      return;
+    } catch {
+      console.warn('http-proxy-middleware not available, skipping proxy setup');
+    }
+  } catch (error) {
+    console.error('[app] Failed to setup proxy:', error);
+  }
+}
+
+/**
+ * Setup Express proxy middleware to forward API requests to backend
+ * (LEGACY - kept for backward compatibility)
+ */
+async function setupProxy(app, backendPort, config) {
+  try {
+    const { createRequire } = await import('node:module');
+    const requireFromRoot = createRequire(path.join(config.root, 'package.json'));
+
+    // Skip proxy for known frontend assets
+    const skipProxy = (req) => {
+      const pathname = req.path || req.url || '';
+      if (!pathname) return true;
+      // Skip Vite internal routes and static assets
+      return (
+        pathname.startsWith('/@') ||
+        pathname.startsWith('/node_modules') ||
+        pathname.startsWith('/src') ||
+        pathname.includes('.hot-update.') ||
+        pathname.includes('.js') ||
+        pathname.includes('.css') ||
+        pathname.includes('.svg') ||
+        pathname.includes('.png') ||
+        pathname.includes('.jpg') ||
+        pathname.includes('.jpeg') ||
+        pathname.includes('.gif') ||
+        pathname.includes('.ico')
+      );
+    };
+
+    const installFallback = (handler) => {
+      // Install middleware that runs AFTER Vite
+      // This will only be reached if Vite doesn't handle the request
+      app.use((req, res, next) => {
+        if (skipProxy(req)) {
+          return next();
+        }
+        // If we reach here and response hasn't been sent, proxy to backend
+        if (!res.headersSent) {
+          return handler(req, res, next);
+        }
+        next();
+      });
+
+      // Also add a 404 handler as the very last middleware
+      app.use((req, res, next) => {
+        if (!res.headersSent && !skipProxy(req)) {
+          // No route handled this, proxy to backend
+          return handler(req, res, next);
+        }
+        // If still not handled, send 404
+        if (!res.headersSent) {
+          res.status(404).send('Not Found');
+        }
+      });
+    };
+
+    // Try to use http-proxy-middleware if available
+    try {
+      const { createProxyMiddleware } = requireFromRoot('http-proxy-middleware');
+      const proxyMiddleware = createProxyMiddleware({
+        target: `http://localhost:${backendPort}`,
+        changeOrigin: true,
+        ws: true,
+        logLevel: config.mode === 'production' ? 'error' : 'info',
+        onProxyReq: (proxyReq, req, res) => {
+          if (config.mode !== 'production') {
+            console.log(`[proxy] ${req.method} ${req.url} -> backend:${backendPort}`);
+          }
+        }
+      });
+      installFallback(proxyMiddleware);
+      console.log(`[app] Proxy fallback configured: unhandled requests will be forwarded to http://localhost:${backendPort}`);
+      return;
+    } catch {
+      // Fallback to express-http-proxy if http-proxy-middleware not available
+    }
+
+    try {
+      const proxy = requireFromRoot('express-http-proxy');
+      const proxyMiddleware = proxy(`http://localhost:${backendPort}`, {
+        proxyReqPathResolver: (req) => req.url,
+        proxyReqOptDecorator: (proxyReqOpts, req) => {
+          proxyReqOpts.headers = proxyReqOpts.headers || {};
+          proxyReqOpts.headers['x-forwarded-host'] = req.headers.host;
+          return proxyReqOpts;
+        }
+      });
+      installFallback(proxyMiddleware);
+      return;
+    } catch {
+      console.warn('Proxy dependencies not found; falling back to built-in proxy handler.');
+    }
+
+    const nativeProxy = (req, res, next) => {
+      const targetPath = req.originalUrl || req.url || '/';
+      if (config.mode !== 'production') {
+        console.log(`[app][proxy] Forwarding ${req.method} ${targetPath} -> http://localhost:${backendPort}`);
+      }
+      const requestHeaders = {
+        ...req.headers,
+        host: `localhost:${backendPort}`,
+        'x-forwarded-host': req.headers.host,
+        'x-forwarded-proto': req.protocol || 'http'
+      };
+
+      const backendRequest = http.request(
+        {
+          hostname: '127.0.0.1',
+          port: backendPort,
+          path: targetPath,
+          method: req.method,
+          headers: requestHeaders
+        },
+        (backendResponse) => {
+          res.status(backendResponse.statusCode || 500);
+          for (const [key, value] of Object.entries(backendResponse.headers)) {
+            if (value !== undefined) {
+              res.setHeader(key, value);
+            }
+          }
+          backendResponse.on('error', (err) => {
+            console.error('[app][proxy] Response error:', err.message);
+            if (!res.headersSent) {
+              res.status(502).end();
+            }
+          });
+          backendResponse.pipe(res);
+        }
+      );
+
+      backendRequest.on('error', (err) => {
+        console.error('[app][proxy] Request error:', err.message);
+        if (!res.headersSent) {
+          res.status(502).end();
+        }
+        next();
+      });
+
+      req.on('aborted', () => {
+        backendRequest.destroy();
+      });
+
+      if (!req.readableEnded && typeof req.pipe === 'function') {
+        req.pipe(backendRequest);
+      } else if (req.body !== undefined && req.body !== null) {
+        let payload;
+        if (Buffer.isBuffer(req.body)) {
+          payload = req.body;
+        } else if (typeof req.body === 'string') {
+          payload = Buffer.from(req.body);
+        } else {
+          try {
+            payload = Buffer.from(JSON.stringify(req.body));
+            backendRequest.setHeader('content-type', backendRequest.getHeader('content-type') || 'application/json');
+          } catch {
+            payload = Buffer.from('');
+          }
+        }
+        if (payload) {
+          backendRequest.setHeader('content-length', String(payload.length));
+          backendRequest.write(payload);
+        }
+        backendRequest.end();
+      } else {
+        backendRequest.end();
+      }
+    };
+
+    installFallback(nativeProxy);
+    return;
+  } catch (err) {
+    console.error(`Failed to setup proxy: ${err.message}`);
+    throw err;
+  }
+}
+
+/**
+ * Run backend service only (Dinner API)
+ */
+async function runBackendService(config) {
+  const appBootModule = await import(toFileUrl(config.app.boot_abs));
+  const backendApp = appBootModule.default(config);
+
+  attachCookiePolyfill(backendApp);
+  
+  setContext(backendApp, config);
+  
+  const serverMainModule = await import(toFileUrl(config.server.main_abs));
+  await serverMainModule.default(backendApp, config);
+  
+  // Use NOEGO_PORT if running as a separate service, otherwise use config
+  const backendPort = process.env.NOEGO_SERVICE === 'backend' ?
+    parseInt(process.env.NOEGO_PORT) : config.dev.backendPort;
+
+  console.log('[backend] NOEGO_SERVICE:', process.env.NOEGO_SERVICE);
+  console.log('[backend] NOEGO_PORT:', process.env.NOEGO_PORT);
+  console.log('[backend] config.dev.backendPort:', config.dev.backendPort);
+  console.log('[backend] Using port:', backendPort);
+
+  backendApp.listen(backendPort, '0.0.0.0', () => {
+    console.log(`Backend server running on http://localhost:${backendPort}`);
+  });
+  
+  return backendApp;
+}
+
+/**
+ * Run frontend service only (Forge SSR + Vite + proxy)
+ */
+async function runFrontendService(config) {
+  const appBootModule = await import(toFileUrl(config.app.boot_abs));
+  const frontendApp = appBootModule.default(config);
+
+  attachCookiePolyfill(frontendApp);
+  
+  if (config.mode !== 'production' && config.client?.assetDirs) {
+    const require = createRequire(path.join(config.root, 'package.json'));
+    const express = require('express');
+    for (const { mountPath, absolutePath } of config.client.assetDirs) {
+      if (mountPath && absolutePath) {
+        frontendApp.use(mountPath, express.static(absolutePath));
+      }
+    }
+  }
+  
+  setContext(frontendApp, config);
+
+  // Only setup proxy if NOT running as a separate frontend service
+  // In split-serve mode, the router handles proxying
+  if (process.env.NOEGO_SERVICE !== 'frontend') {
+    // Setup proxy BEFORE Vite/Forge middleware, but as a selective passthrough
+    const backendPort = config.dev.backendPort;
+    await setupProxyFirst(frontendApp, backendPort, config);
+  }
+
+  const clientMainModule = await import(toFileUrl(config.client.main_abs));
+  await clientMainModule.default(frontendApp, config);
+
+  // Use NOEGO_PORT if running as a separate service, otherwise use config
+  const frontendPort = process.env.NOEGO_SERVICE === 'frontend' ?
+    parseInt(process.env.NOEGO_PORT) : config.dev.port;
+
+  console.log('[frontend] NOEGO_SERVICE:', process.env.NOEGO_SERVICE);
+  console.log('[frontend] NOEGO_PORT:', process.env.NOEGO_PORT);
+  console.log('[frontend] config.dev.port:', config.dev.port);
+  console.log('[frontend] Using port:', frontendPort);
+
+  frontendApp.listen(frontendPort, '0.0.0.0', () => {
+    console.log(`Frontend server running on http://localhost:${frontendPort}`);
+  });
+  
+  return frontendApp;
+}
+
+/**
+ * Run router service that proxies to frontend/backend
+ */
+async function runRouterService(config) {
+  const appBootModule = await import(toFileUrl(config.app.boot_abs));
+  const routerApp = appBootModule.default(config);
+
+  attachCookiePolyfill(routerApp);
+
+  const routerPort = config.dev.port;
+  const frontendPort = parseInt(process.env.NOEGO_FRONTEND_PORT) || (routerPort + 1);
+  const backendPort = parseInt(process.env.NOEGO_BACKEND_PORT) || (routerPort + 2);
+
+  setContext(routerApp, config);
+
+  // Simple native proxy implementation that tries frontend first, then backend on 404
+  routerApp.use(async (req, res, next) => {
+    const originalUrl = req.url;
+    const method = req.method;
+
+    // Collect the request body
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+
+    req.on('end', async () => {
+      const bodyBuffer = Buffer.concat(chunks);
+
+      // First try frontend
+      const tryService = (port, serviceName) => {
+        return new Promise((resolve) => {
+          // Hop-by-hop headers that shouldn't be forwarded
+          const hopByHopHeaders = [
+            'connection',
+            'keep-alive',
+            'proxy-authenticate',
+            'proxy-authorization',
+            'te',
+            'trailers',
+            'transfer-encoding',
+            'upgrade'
+          ];
+
+          // Copy headers, excluding hop-by-hop headers
+          const headers = {};
+          Object.keys(req.headers).forEach(key => {
+            if (!hopByHopHeaders.includes(key.toLowerCase())) {
+              headers[key] = req.headers[key];
+            }
+          });
+
+          // If there's a body, ensure content-length is correct
+          if (bodyBuffer.length > 0) {
+            headers['content-length'] = bodyBuffer.length;
+          }
+
+          // Preserve original host information for downstream auth/cookie logic
+          const originalHost = req.headers.host;
+          if (originalHost) {
+            if (!headers['x-forwarded-host']) {
+              headers['x-forwarded-host'] = originalHost;
+            }
+            if (!headers['x-forwarded-proto']) {
+              headers['x-forwarded-proto'] = req.protocol || 'http';
+            }
+            if (!headers['x-forwarded-port']) {
+              const hostPort = originalHost.split(':')[1];
+              headers['x-forwarded-port'] = hostPort || (headers['x-forwarded-proto'] === 'https' ? '443' : '80');
+            }
+          }
+
+          // Debug logging for authentication-related headers
+          if (headers.cookie || headers.authorization) {
+            console.log(`[router] Forwarding auth headers to ${serviceName}:`, {
+              cookie: headers.cookie ? 'present' : 'absent',
+              authorization: headers.authorization ? 'present' : 'absent'
+            });
+          }
+
+          const options = {
+            hostname: 'localhost',
+            port: port,
+            path: originalUrl,
+            method: method,
+            headers: headers
+          };
+
+          const proxyReq = http.request(options, (proxyRes) => {
+            const responseChunks = [];
+
+            // Debug logging for authentication response headers
+            if (proxyRes.headers['set-cookie'] || proxyRes.statusCode === 401 || proxyRes.statusCode === 403) {
+              console.log(`[router] Response from ${serviceName}:`, {
+                status: proxyRes.statusCode,
+                'set-cookie': proxyRes.headers['set-cookie'] ? 'present' : 'absent'
+              });
+            }
+
+            proxyRes.on('data', chunk => responseChunks.push(chunk));
+            proxyRes.on('end', () => {
+              resolve({
+                statusCode: proxyRes.statusCode,
+                headers: proxyRes.headers,
+                body: Buffer.concat(responseChunks),
+                serviceName
+              });
+            });
+          });
+
+          proxyReq.on('error', (err) => {
+            console.error(`[router] Error proxying to ${serviceName}: ${err.message}`);
+            resolve({ statusCode: 502, error: err, serviceName });
+          });
+
+          if (bodyBuffer.length > 0) {
+            proxyReq.write(bodyBuffer);
+          }
+          proxyReq.end();
+        });
+      };
+
+      // Try frontend first
+      const frontendResult = await tryService(frontendPort, 'frontend');
+
+      // Helper to forward response headers, excluding hop-by-hop headers
+      const forwardResponseHeaders = (headers, res) => {
+        const hopByHopHeaders = [
+          'connection',
+          'keep-alive',
+          'proxy-authenticate',
+          'proxy-authorization',
+          'te',
+          'trailers',
+          'transfer-encoding',
+          'upgrade'
+        ];
+
+        if (headers) {
+          Object.entries(headers).forEach(([key, value]) => {
+            const keyLower = key.toLowerCase();
+            if (hopByHopHeaders.includes(keyLower)) {
+              return;
+            }
+
+            if (keyLower === 'set-cookie') {
+              const cookies = Array.isArray(value) ? value : [value];
+              if (typeof res.append === 'function') {
+                cookies.forEach((cookie) => res.append('set-cookie', cookie));
+              } else {
+                res.setHeader('set-cookie', cookies);
+              }
+              return;
+            }
+
+            res.setHeader(key, value);
+          });
+        }
+      };
+
+      if (frontendResult.statusCode === 404) {
+        // Frontend returned 404, try backend
+        console.log(`[router] Frontend returned 404 for ${method} ${originalUrl}, trying backend...`);
+        const backendResult = await tryService(backendPort, 'backend');
+
+        // Send backend response
+        res.statusCode = backendResult.statusCode || 502;
+        forwardResponseHeaders(backendResult.headers, res);
+        if (backendResult.body) {
+          res.end(backendResult.body);
+        } else {
+          res.end(backendResult.error ? 'Backend proxy error' : '');
+        }
+      } else {
+        // Frontend handled it or returned non-404 error
+        res.statusCode = frontendResult.statusCode || 502;
+        forwardResponseHeaders(frontendResult.headers, res);
+        if (frontendResult.body) {
+          res.end(frontendResult.body);
+        } else {
+          res.end(frontendResult.error ? 'Frontend proxy error' : '');
+        }
+      }
+    });
+  });
+
+  routerApp.listen(routerPort, '0.0.0.0', () => {
+    console.log(`Router server running on http://localhost:${routerPort}`);
+    console.log(`  Proxying to frontend on port ${frontendPort}`);
+    console.log(`  Proxying to backend on port ${backendPort}`);
+  });
+
+  return routerApp;
+}
+
+/**
+ * Run combined services in one process (backend and/or frontend based on configuration)
+ */
+export async function runCombinedServices(config, options = {}) {
+  const { hasBackend = true, hasFrontend = true } = options;
+  
+  const appBootModule = await import(toFileUrl(config.app.boot_abs));
+  const app = appBootModule.default(config);
+
+  attachCookiePolyfill(app);
+  
+  if (config.mode !== 'production' && config.client?.assetDirs) {
+    const require = createRequire(path.join(config.root, 'package.json'));
+    const express = require('express');
+    for (const { mountPath, absolutePath } of config.client.assetDirs) {
+      if (mountPath && absolutePath) {
+        app.use(mountPath, express.static(absolutePath));
+      }
+    }
+  }
+  
+  if (config.mode === 'production' && hasFrontend && config.outDir_abs) {
+    const require = createRequire(path.join(config.root, 'package.json'));
+    const express = require('express');
+    const clientStaticPath = path.join(config.outDir_abs, '.app', 'assets');
+    app.use('/client', express.static(clientStaticPath));
+  }
+  
+  const httpServer = http.createServer(app);
+  setContext(app, config, httpServer);
+  
+  if (hasBackend && config.server?.main_abs) {
+    const serverMainModule = await import(toFileUrl(config.server.main_abs));
+    await serverMainModule.default(app, config);
+  }
+  
+  if (hasFrontend && config.client?.main_abs) {
+    const clientMainModule = await import(toFileUrl(config.client.main_abs));
+    await clientMainModule.default(app, config);
+  }
+
+  // Allow PORT env var to override config
+  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : (config.dev?.port || 3000);
+  httpServer.listen(port, '0.0.0.0', () => {
+    const services = [];
+    if (hasBackend && config.server?.main_abs) services.push('Backend');
+    if (hasFrontend && config.client?.main_abs) services.push('Frontend');
+    const servicesStr = services.length > 0 ? ` (${services.join(' + ')})` : '';
+    console.log(`Server running on http://localhost:${port}${servicesStr}`);
+  });
+
+  return app;
+}
+
+export async function runRuntime(configFilePath, cliRoot) {
+  let config;
+
+  // Priority: Use env config if NOEGO_CONFIGURATION is set and no explicit config file
+  if (process.env.NOEGO_CONFIGURATION && !configFilePath) {
+    const { loadConfigFromEnv } = await import('./config-loader.js');
+    const result = loadConfigFromEnv();
+    config = result.config;
+  } else {
+    // Traditional path: load from YAML file
+    const result = await loadConfig(configFilePath, cliRoot);
+    config = result.config;
+  }
+
+  // Force development mode when running dev command (NODE_ENV is set to development)
+  // Override YAML config mode to ensure Vite runs in dev mode
+  if (process.env.NODE_ENV !== 'production') {
+    config.mode = 'development';
+  } else if (!config.mode) {
+    config.mode = 'production';
+  }
+  
+  // Validate critical configuration
+  if (!config.app?.boot) {
+    throw new Error('app.boot is required in configuration');
+  }
+  
+  // Check if running as a specific service (split-serve mode with separate processes)
+  const serviceMode = process.env.NOEGO_SERVICE; // 'router', 'backend', 'frontend', or undefined
+
+  if (serviceMode === 'router') {
+    // Router service runs in the main process
+    return await runRouterService(config);
+  } else if (serviceMode === 'backend') {
+    if (!config.server?.main_abs) {
+      throw new Error('server.main is required when NOEGO_SERVICE=backend');
+    }
+    return await runBackendService(config);
+  } else if (serviceMode === 'frontend') {
+    if (!config.client?.main_abs) {
+      throw new Error('client.main is required when NOEGO_SERVICE=frontend');
+    }
+    return await runFrontendService(config);
+  }
+  
+  const splitServe = config.dev?.splitServe || false;
+  const hasBackend = !!config.server?.main_abs;
+  const hasFrontend = !!config.client?.main_abs;
+  
+  if (splitServe) {
+    if (!hasBackend || !hasFrontend) {
+      throw new Error('splitServe requires both server.main and client.main to be configured');
+    }
+    throw new Error('Split-serve should be handled by dev.js spawning separate processes');
+  }
+  
+  return await runCombinedServices(config, { hasBackend, hasFrontend });
+}