@noego/app 0.0.22 → 0.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/app",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "Production build tool for Dinner/Forge apps.",
   "type": "module",
   "bin": {
@@ -33,6 +33,7 @@
   "license": "MIT",
   "author": "App Build CLI",
   "dependencies": {
+    "@noego/logger": "file:../logger",
     "deepmerge": "^4.3.1",
     "glob-parent": "^6.0.2",
     "http-proxy": "^1.18.1",

package/src/build/server.js

@@ -1,10 +1,13 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 // No URL utilities needed when not vendoring Forge
+import { getLogger } from '@noego/logger';
 
 import { runCommand } from '../utils/command.js';
 import { fixImportExtensions } from './fix-imports.js';
 
+const log = getLogger('app');
+
 export async function buildServer(context, discovery) {
   const { logger } = context;
   logger.info('Building server bundle');
@@ -182,7 +185,7 @@ async function mirrorUiModules(context) {
 
   // Overlay compiled UI outputs from tsc emit so .ts becomes .js under mirrored UI root
   if (config.verbose) {
-    console.log('[server] overlayUi called:', {
+    log.debug('overlayUi called:', {
       'config.ui': config.ui,
       'config.ui.rootDir': config.ui?.rootDir,
       'config.rootDir': config.rootDir

package/src/build/ssr.js

@@ -1,11 +1,14 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { getLogger } from '@noego/logger';
 
 import { buildWithVite } from './vite.js';
 import { createUiBuildConfig } from './ui-common.js';
 import { resolveClientEntry } from './client.js';
 
+const log = getLogger('app');
+
 export async function resolveSsrBuildConfig(context, discovery) {
   const { config } = context;
   const { entryAbsolute } = await resolveClientEntry(context);
@@ -352,7 +355,7 @@ function buildSsrManifest(config, discovery) {
 
 function componentToSsrPath(componentPath, config) {
   if (config.verbose) {
-    console.log('[ssr] componentToSsrPath called:', {
+    log.debug('componentToSsrPath called:', {
       componentPath,
       'config.ui': config.ui,
       'config.ui.rootDir': config.ui?.rootDir,

package/src/cli.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
+import { getLogger } from '@noego/logger';
 
 import { parseCliArgs, printHelpAndExit } from './args.js';
 import { loadBuildConfig } from './config.js';
@@ -9,6 +10,8 @@ import { runServe } from './commands/serve.js';
 import { runPreview } from './commands/preview.js';
 import { runDev } from './commands/dev.js';
 
+const log = getLogger('app');
+
 export async function runCli(argv = process.argv.slice(2)) {
   try {
     const { command, options } = parseCliArgs(argv);
@@ -56,7 +59,7 @@ export async function runCli(argv = process.argv.slice(2)) {
 
     process.stderr.write(`[app] ${error?.message || error}\n`);
     if (process.env.APP_DEBUG || process.env.HAMMER_DEBUG) {
-      console.error(error);
+      log.error(error);
     }
     process.exitCode = 1;
   }

package/src/commands/dev.js

@@ -11,8 +11,10 @@ import { waitForPortFree } from '../utils/port.js';
 import { stopProcess, killProcessTree as killProcessTreeUtil } from '../utils/process-observable.js';
 import { watcherToObservable, FileEventType } from '../utils/file-watcher-observable.js';
 import treeKill from 'tree-kill';
+import { getLogger } from '@noego/logger';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const log = getLogger('app');
 
 /**
  * Kill a process and all its descendants (entire process tree)
@@ -287,12 +289,12 @@ async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort,
   logger.info(`Starting frontend on port ${frontendPort}...`);
   logger.info(`Starting backend on port ${backendPort}...`);
 
-  console.log('[dev.js] Port assignments:');
-  console.log('  routerPort:', routerPort);
-  console.log('  frontendPort:', frontendPort);
-  console.log('  backendPort:', backendPort);
-  console.log('[dev.js] baseEnv NOEGO_PORT:', baseEnv.NOEGO_PORT);
-  console.log('[dev.js] baseEnv NOEGO_BACKEND_PORT:', baseEnv.NOEGO_BACKEND_PORT);
+  log.debug('Port assignments:');
+  log.debug('  routerPort:', routerPort);
+  log.debug('  frontendPort:', frontendPort);
+  log.debug('  backendPort:', backendPort);
+  log.debug('baseEnv NOEGO_PORT:', baseEnv.NOEGO_PORT);
+  log.debug('baseEnv NOEGO_BACKEND_PORT:', baseEnv.NOEGO_BACKEND_PORT);
 
   // Spawn backend process
   const backendEnv = {
@@ -301,7 +303,7 @@ async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort,
     NOEGO_PORT: String(backendPort)
   };
 
-  console.log('[dev.js] Backend env NOEGO_PORT:', backendEnv.NOEGO_PORT);
+  log.debug('Backend env NOEGO_PORT:', backendEnv.NOEGO_PORT);
 
   const backendProc = spawn(tsxExecutable, tsxArgs, {
     cwd: rootDir,
@@ -318,7 +320,7 @@ async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort,
     // Frontend doesn't proxy to backend anymore - router handles that
   };
 
-  console.log('[dev.js] Frontend env NOEGO_PORT:', frontendEnv.NOEGO_PORT);
+  log.debug('Frontend env NOEGO_PORT:', frontendEnv.NOEGO_PORT);
 
   const frontendProc = spawn(tsxExecutable, tsxArgs, {
     cwd: rootDir,

package/src/commands/preview.js

@@ -1,4 +1,5 @@
 import util from 'node:util';
+import { getLogger } from '@noego/logger';
 
 import { createBuildContext } from '../build/context.js';
 import { discoverProject } from '../build/openapi.js';
@@ -9,12 +10,13 @@ import {
   resolveRecursiveRendererBuildConfig
 } from '../build/ssr.js';
 
+const log = getLogger('app');
 const INSPECT_OPTIONS = { depth: null, colors: false };
 
 function printSection(heading, payload) {
-  console.log(`========== ${heading} ==========`);
-  console.log(util.inspect(payload, INSPECT_OPTIONS));
-  console.log();
+  log.info(`========== ${heading} ==========`);
+  log.info(util.inspect(payload, INSPECT_OPTIONS));
+  log.info('');
 }
 
 export async function runPreview(config) {

package/src/commands/runtime-entry.js

@@ -1,16 +1,19 @@
 import { runRuntime } from '../runtime/runtime.js';
+import { getLogger } from '@noego/logger';
+
+const log = getLogger('app');
 
 // This file is run via tsx, so it can import TypeScript files
 const configFilePath = process.env.NOEGO_CONFIG_FILE;
 const cliRoot = process.env.NOEGO_CLI_ROOT;
 
 if (!configFilePath) {
-  console.error('NOEGO_CONFIG_FILE environment variable is required');
+  log.error('NOEGO_CONFIG_FILE environment variable is required');
   process.exit(1);
 }
 
 runRuntime(configFilePath, cliRoot || undefined).catch((error) => {
-  console.error('Runtime error:', error);
+  log.error('Runtime error:', error);
   process.exit(1);
 });
 

package/src/config.js

@@ -48,7 +48,7 @@ export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } =
   const uiRelRoot = uiRootDir ? path.relative(config.root, uiRootDir) : null;
 
   if (cliOptions.verbose) {
-    console.log('[config] uiRootDir calculation:', {
+    log.debug('uiRootDir calculation:', {
       'config.client': config.client,
       'config.client.main_abs': config.client?.main_abs,
       'uiRootDir': uiRootDir,

package/src/logger.js

@@ -1,16 +1,5 @@
-import process from 'node:process';
+import { getLogger } from '@noego/logger';
 
-export function createLogger({ verbose = false } = {}) {
-  const debugEnabled = verbose || Boolean(process.env.APP_DEBUG || process.env.HAMMER_DEBUG);
-
-  return {
-    info: (...args) => console.log('[app]', ...args),
-    warn: (...args) => console.warn('[app]', ...args),
-    error: (...args) => console.error('[app]', ...args),
-    debug: (...args) => {
-      if (debugEnabled) {
-        console.log('[app:debug]', ...args);
-      }
-    }
-  };
+export function createLogger() {
+  return getLogger('app');
 }

package/src/runtime/runtime.js

@@ -4,9 +4,16 @@ import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 import { loadConfig } from './config-loader.js';
 import { setContext } from '../client.js';
+import { getLogger } from '@noego/logger';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+const log = getLogger('app');
+const proxyLog = getLogger('app:proxy');
+const routerLog = getLogger('app:router');
+const frontendLog = getLogger('app:frontend');
+const backendLog = getLogger('app:backend');
+
 function toFileUrl(filePath) {
   return `file://${filePath}`;
 }
@@ -148,7 +155,7 @@ async function setupProxyFirst(app, backendPort, config) {
         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}`);
+            proxyLog.debug(`${req.method} ${req.url} -> backend:${backendPort}`);
           }
         }
       });
@@ -175,18 +182,18 @@ async function setupProxyFirst(app, backendPort, config) {
           }
         } catch (err) {
           // On any error, fall back to Vite/Forge
-          console.error('[proxy] Error checking backend:', err);
+          proxyLog.error('Error checking backend:', err);
           next();
         }
       });
 
-      console.log(`[app] Dynamic proxy configured: checking backend at http://localhost:${backendPort} for non-asset routes`);
+      log.info(`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');
+      log.warn('http-proxy-middleware not available, skipping proxy setup');
     }
   } catch (error) {
-    console.error('[app] Failed to setup proxy:', error);
+    log.error('Failed to setup proxy:', error);
   }
 }
 
@@ -257,12 +264,12 @@ async function setupProxy(app, backendPort, config) {
         logLevel: config.mode === 'production' ? 'error' : 'info',
         onProxyReq: (proxyReq, req, res) => {
           if (config.mode !== 'production') {
-            console.log(`[proxy] ${req.method} ${req.url} -> backend:${backendPort}`);
+            proxyLog.debug(`${req.method} ${req.url} -> backend:${backendPort}`);
           }
         }
       });
       installFallback(proxyMiddleware);
-      console.log(`[app] Proxy fallback configured: unhandled requests will be forwarded to http://localhost:${backendPort}`);
+      log.info(`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
@@ -281,13 +288,13 @@ async function setupProxy(app, backendPort, config) {
       installFallback(proxyMiddleware);
       return;
     } catch {
-      console.warn('Proxy dependencies not found; falling back to built-in proxy handler.');
+      log.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}`);
+        proxyLog.debug(`Forwarding ${req.method} ${targetPath} -> http://localhost:${backendPort}`);
       }
       const requestHeaders = {
         ...req.headers,
@@ -312,7 +319,7 @@ async function setupProxy(app, backendPort, config) {
             }
           }
           backendResponse.on('error', (err) => {
-            console.error('[app][proxy] Response error:', err.message);
+            proxyLog.error('Response error:', err.message);
             if (!res.headersSent) {
               res.status(502).end();
             }
@@ -322,7 +329,7 @@ async function setupProxy(app, backendPort, config) {
       );
 
       backendRequest.on('error', (err) => {
-        console.error('[app][proxy] Request error:', err.message);
+        proxyLog.error('Request error:', err.message);
         if (!res.headersSent) {
           res.status(502).end();
         }
@@ -362,7 +369,7 @@ async function setupProxy(app, backendPort, config) {
     installFallback(nativeProxy);
     return;
   } catch (err) {
-    console.error(`Failed to setup proxy: ${err.message}`);
+    log.error(`Failed to setup proxy: ${err.message}`);
     throw err;
   }
 }
@@ -385,26 +392,26 @@ async function runBackendService(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);
+  backendLog.debug('NOEGO_SERVICE:', process.env.NOEGO_SERVICE);
+  backendLog.debug('NOEGO_PORT:', process.env.NOEGO_PORT);
+  backendLog.debug('config.dev.backendPort:', config.dev.backendPort);
+  backendLog.debug('Using port:', backendPort);
 
   const httpServer = http.createServer(backendApp);
 
   httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {
-      console.error(`[ERROR] Port ${backendPort} is already in use (EADDRINUSE)`);
-      console.error(`[ERROR] This likely means a stale process is still running.`);
-      console.error(`[ERROR] The dev server will attempt to recover...`);
+      backendLog.error(`Port ${backendPort} is already in use (EADDRINUSE)`);
+      backendLog.error(`This likely means a stale process is still running.`);
+      backendLog.error(`The dev server will attempt to recover...`);
     } else {
-      console.error(`[ERROR] Server error on port ${backendPort}:`, err.message);
+      backendLog.error(`Server error on port ${backendPort}:`, err.message);
     }
     process.exit(1);
   });
 
   httpServer.listen(backendPort, '0.0.0.0', () => {
-    console.log(`Backend server running on http://localhost:${backendPort}`);
+    backendLog.info(`Backend server running on http://localhost:${backendPort}`);
   });
 
   return backendApp;
@@ -449,24 +456,24 @@ async function runFrontendService(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);
+  frontendLog.debug('NOEGO_SERVICE:', process.env.NOEGO_SERVICE);
+  frontendLog.debug('NOEGO_PORT:', process.env.NOEGO_PORT);
+  frontendLog.debug('config.dev.port:', config.dev.port);
+  frontendLog.debug('Using port:', frontendPort);
 
   httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {
-      console.error(`[ERROR] Port ${frontendPort} is already in use (EADDRINUSE)`);
-      console.error(`[ERROR] This likely means a stale process is still running.`);
-      console.error(`[ERROR] The dev server will attempt to recover...`);
+      frontendLog.error(`Port ${frontendPort} is already in use (EADDRINUSE)`);
+      frontendLog.error(`This likely means a stale process is still running.`);
+      frontendLog.error(`The dev server will attempt to recover...`);
     } else {
-      console.error(`[ERROR] Server error on port ${frontendPort}:`, err.message);
+      frontendLog.error(`Server error on port ${frontendPort}:`, err.message);
     }
     process.exit(1);
   });
 
   httpServer.listen(frontendPort, '0.0.0.0', () => {
-    console.log(`Frontend server running on http://localhost:${frontendPort}`);
+    frontendLog.info(`Frontend server running on http://localhost:${frontendPort}`);
   });
   
   return frontendApp;
@@ -546,7 +553,7 @@ async function runRouterService(config) {
 
           // Debug logging for authentication-related headers
           if (headers.cookie || headers.authorization) {
-            console.log(`[router] Forwarding auth headers to ${serviceName}:`, {
+            routerLog.debug(`Forwarding auth headers to ${serviceName}:`, {
               cookie: headers.cookie ? 'present' : 'absent',
               authorization: headers.authorization ? 'present' : 'absent'
             });
@@ -565,7 +572,7 @@ async function runRouterService(config) {
 
             // Debug logging for authentication response headers
             if (proxyRes.headers['set-cookie'] || proxyRes.statusCode === 401 || proxyRes.statusCode === 403) {
-              console.log(`[router] Response from ${serviceName}:`, {
+              routerLog.debug(`Response from ${serviceName}:`, {
                 status: proxyRes.statusCode,
                 'set-cookie': proxyRes.headers['set-cookie'] ? 'present' : 'absent'
               });
@@ -583,7 +590,7 @@ async function runRouterService(config) {
           });
 
           proxyReq.on('error', (err) => {
-            console.error(`[router] Error proxying to ${serviceName}: ${err.message}`);
+            routerLog.error(`Error proxying to ${serviceName}: ${err.message}`);
             resolve({ statusCode: 502, error: err, serviceName });
           });
 
@@ -634,7 +641,7 @@ async function runRouterService(config) {
 
       if (frontendResult.statusCode === 404) {
         // Frontend returned 404, try backend
-        console.log(`[router] Frontend returned 404 for ${method} ${originalUrl}, trying backend...`);
+        routerLog.info(`Frontend returned 404 for ${method} ${originalUrl}, trying backend...`);
         const backendResult = await tryService(backendPort, 'backend');
 
         // Send backend response
@@ -679,36 +686,36 @@ async function runRouterService(config) {
     // Only route to backend if explicitly needed (currently none)
     const target = `ws://localhost:${frontendPort}`;
 
-    console.log(`[router][ws] Routing WebSocket ${url} to ${target}`);
+    routerLog.debug(`[ws] Routing WebSocket ${url} to ${target}`);
 
     wsProxy.ws(req, socket, head, { target }, (err) => {
-      console.error('[router][ws] proxy error:', err?.message);
+      routerLog.error('[ws] proxy error:', err?.message);
       try { socket.destroy(); } catch {}
     });
   });
 
   // Optional: observe proxy-level errors
   wsProxy.on('error', (err, req, socket) => {
-    console.error('[router][ws] proxy error (global):', err?.message);
+    routerLog.error('[ws] proxy error (global):', err?.message);
     try { socket?.destroy?.(); } catch {}
   });
 
   httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {
-      console.error(`[ERROR] Port ${routerPort} is already in use (EADDRINUSE)`);
-      console.error(`[ERROR] This likely means a stale process is still running.`);
-      console.error(`[ERROR] The dev server will attempt to recover...`);
+      routerLog.error(`Port ${routerPort} is already in use (EADDRINUSE)`);
+      routerLog.error(`This likely means a stale process is still running.`);
+      routerLog.error(`The dev server will attempt to recover...`);
     } else {
-      console.error(`[ERROR] Server error on port ${routerPort}:`, err.message);
+      routerLog.error(`Server error on port ${routerPort}:`, err.message);
     }
     process.exit(1);
   });
 
   httpServer.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}`);
-    console.log(`  WebSocket support enabled via http-proxy`);
+    routerLog.info(`Router server running on http://localhost:${routerPort}`);
+    routerLog.info(`  Proxying to frontend on port ${frontendPort}`);
+    routerLog.info(`  Proxying to backend on port ${backendPort}`);
+    routerLog.info(`  WebSocket support enabled via http-proxy`);
   });
 
   return routerApp;
@@ -762,11 +769,11 @@ export async function runCombinedServices(config, options = {}) {
 
   httpServer.on('error', (err) => {
     if (err.code === 'EADDRINUSE') {
-      console.error(`[ERROR] Port ${port} is already in use (EADDRINUSE)`);
-      console.error(`[ERROR] This likely means a stale process is still running.`);
-      console.error(`[ERROR] The dev server will attempt to recover...`);
+      log.error(`Port ${port} is already in use (EADDRINUSE)`);
+      log.error(`This likely means a stale process is still running.`);
+      log.error(`The dev server will attempt to recover...`);
     } else {
-      console.error(`[ERROR] Server error on port ${port}:`, err.message);
+      log.error(`Server error on port ${port}:`, err.message);
     }
     process.exit(1);
   });
@@ -776,7 +783,7 @@ export async function runCombinedServices(config, options = {}) {
     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}`);
+    log.info(`Server running on http://localhost:${port}${servicesStr}`);
   });
 
   return app;

package/src/utils/port.js

@@ -1,6 +1,9 @@
 import { Observable, interval, of, throwError } from 'rxjs';
 import { map, switchMap, filter, take, timeout, catchError } from 'rxjs/operators';
 import net from 'node:net';
+import { getLogger } from '@noego/logger';
+
+const log = getLogger('app');
 
 /**
  * Check if a port is currently free (available for binding)
@@ -67,7 +70,7 @@ export function waitForPortFree(port, timeoutMs = 5000, pollInterval = 50) {
     }),
     // Provide graceful fallback on timeout (continue anyway but log warning)
     catchError((err) => {
-      console.warn(`[port.js] Warning: ${err.message}. Proceeding anyway.`);
+      log.warn(`Warning: ${err.message}. Proceeding anyway.`);
       return of(undefined);
     })
   );
@@ -97,7 +100,7 @@ export function waitForPortInUse(port, timeoutMs = 10000, pollInterval = 100) {
     }),
     // Provide graceful fallback on timeout
     catchError((err) => {
-      console.warn(`[port.js] Warning: ${err.message}. Proceeding anyway.`);
+      log.warn(`Warning: ${err.message}. Proceeding anyway.`);
       return of(undefined);
     })
   );

package/src/utils/process-observable.js

@@ -1,6 +1,9 @@
 import { Observable, of, timer, race, EMPTY } from 'rxjs';
 import { map, switchMap, take, catchError, finalize, tap } from 'rxjs/operators';
 import { spawn, execSync } from 'node:child_process';
+import { getLogger } from '@noego/logger';
+
+const log = getLogger('app');
 
 /**
  * Process event types emitted by spawnProcess observable
@@ -149,7 +152,7 @@ export function stopProcess(proc, gracefulTimeout = 5000, killTreeFn = killProce
     // Set up force kill timer
     forceKillTimer = setTimeout(() => {
       if (!exited && pid) {
-        console.warn(`[process-observable] Process ${pid} didn't exit gracefully, force killing...`);
+        log.warn(`Process ${pid} didn't exit gracefully, force killing...`);
         killTreeFn(pid, 'SIGKILL');
       }
     }, gracefulTimeout);
@@ -211,7 +214,7 @@ export function stopProcessAndVerify(proc, gracefulTimeout = 5000, killTreeFn =
     switchMap(() => timer(50)),
     map(() => undefined),
     catchError((err) => {
-      console.warn(`[process-observable] Error stopping process: ${err.message}`);
+      log.warn(`Error stopping process: ${err.message}`);
       return of(undefined);
     })
   );