@manojkmfsi/monodog 1.0.23 → 1.0.25

package/src/controllers/{packageController.ts → package-controller.ts}

@@ -1,7 +1,8 @@
-import { updatePackageConfigurationService } from '../services/configService';
-import { getPackageDetailService, getPackagesService, refreshPackagesService } from '../services/packageService';
+import { Request, Response } from 'express';
+import { updatePackageConfigurationService } from '../services/config-service';
+import { getPackageDetailService, getPackagesService, refreshPackagesService } from '../services/package-service';
 
-export const getPackages = async (_req: any, res: any) => {
+export const getPackages = async (_req: Request, res: Response) => {
   try {
     const transformedPackages = await getPackagesService(_req.app.locals.rootPath);
     res.json(transformedPackages);
@@ -10,7 +11,7 @@ export const getPackages = async (_req: any, res: any) => {
   }
 }
 
-export const refreshPackages = async (_req: any, res: any) => {
+export const refreshPackages = async (_req: Request, res: Response) => {
   console.log('Refreshing packages from source...'+ _req.app.locals.rootPath);
 
   try {
@@ -21,7 +22,7 @@ export const refreshPackages = async (_req: any, res: any) => {
   }
 }
 
-export const getPackageDetail = async (_req: any, res: any) => {
+export const getPackageDetail = async (_req: Request, res: Response) => {
   const { name } = _req.params;
   try {
     const packageDetail = await getPackageDetailService(name)
@@ -31,7 +32,7 @@ export const getPackageDetail = async (_req: any, res: any) => {
   }
 }
 
-export const updatePackageConfig = async (req: any, res: any) => {
+export const updatePackageConfig = async (req: Request, res: Response) => {
   try {
     const { packageName, config, packagePath } = req.body;
 

package/src/index.ts

@@ -1,281 +1,9 @@
-import express, {
-  type Request,
-  type Response,
-  type NextFunction,
-  type ErrorRequestHandler,
-} from 'express';
-
-import cors from 'cors';
-import path from 'path';
-import { json } from 'body-parser';
-import helmet from 'helmet';
-
-import { appConfig } from './config-loader';
-
-import packageRouter from './routes/packageRoutes';
-import commitRouter from './routes/commitRoutes';
-import healthRouter from './routes/healthRoutes';
-import configRouter from './routes/configRoutes';
-
-// Security constants
-const PORT_MIN = 1024;
-const PORT_MAX = 65535;
-
-// Validate port number
-function validatePort(port: string | number): number {
-  const portNum = typeof port === 'string' ? parseInt(port, 10) : port;
-
-  if (isNaN(portNum) || portNum < PORT_MIN || portNum > PORT_MAX) {
-    throw new Error(`Port must be between ${PORT_MIN} and ${PORT_MAX}`);
-  }
-
-  return portNum;
-}
-
-// Global error handler
-const errorHandler: ErrorRequestHandler = (err: any, req: Request, res: Response, _next: NextFunction) => {
-  const status = err.status || err.statusCode || 500;
-
-  console.error('[ERROR]', {
-    status,
-    method: req.method,
-    path: req.path,
-    message: err.message,
-  });
-
-  res.status(status).json({
-    error: 'Internal server error'
-  });
-};
-
-// The main function exported and called by the CLI
-export function startServer(
-  rootPath: string
-): void {
-
-  try {
-    const port = appConfig.server.port;
-    const host = appConfig.server.host;
-    const validatedPort = validatePort(port);
-    const app = express();
-
-    // Set request timeout (30 seconds)
-    app.use((req, res, next) => {
-      req.setTimeout(30000);
-      res.setTimeout(30000);
-      next();
-    });
-
-    app.locals.rootPath = rootPath;
-
-    // Security middleware with CSP allowing API calls
-    const apiHost = host === '0.0.0.0' ? 'localhost' : host;
-    const apiUrl = process.env.API_URL || `http://${apiHost}:${validatedPort}`;
-    const dashboardHost = appConfig.dashboard.host === '0.0.0.0' ? 'localhost' : appConfig.dashboard.host;
-    const dashboardUrl = `http://${dashboardHost}:${appConfig.dashboard.port}`;
-
-    app.use(helmet({
-      contentSecurityPolicy: {
-        directives: {
-          defaultSrc: ["'self'"],
-          connectSrc: ["'self'", apiUrl, 'http://localhost:*', 'http://127.0.0.1:*'],
-          scriptSrc: ["'self'"],
-          imgSrc: ["'self'", 'data:', 'https:'],
-        },
-      },
-    }));
-    app.use(cors({
-      origin: process.env.CORS_ORIGIN || dashboardUrl,
-      credentials: true,
-      methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-      allowedHeaders: ['Content-Type', 'Authorization'],
-    }));
-
-    app.use(json({ limit: '1mb' }));
-
-    // Request logging middleware (safe version)
-    app.use((_req: Request, _res: Response, next: NextFunction) => {
-      console.log(`[${new Date().toISOString()}] ${_req.method} ${_req.path}`);
-      next();
-    });
-
-    app.use('/api/packages', packageRouter);
-
-    // Get commit details
-    app.use('/api/commits/', commitRouter);
-
-    // Health check endpoint
-    app.use('/api/health/', healthRouter);
-
-    // Configuration endpoint
-    app.use('/api/config/', configRouter);
-
-    // 404 handler
-    app.use('*', (_, res) => {
-      res.status(404).json({
-        error: 'Endpoint not found',
-        timestamp: Date.now(),
-      });
-    });
-
-    // Global error handler (must be last)
-    app.use(errorHandler);
-
-    const server = app.listen(validatedPort, host, () => {
-      console.log(`Backend server running on http://${host}:${validatedPort}`);
-      console.log(`API endpoints available:`);
-      console.log(`   - GET  /api/health`);
-      console.log(`   - GET  /api/packages/refresh`);
-      console.log(`   - GET  /api/packages`);
-      console.log(`   - GET  /api/packages/:name`);
-      console.log(`   - PUT  /api/packages/update-config`);
-      console.log(`   - GET  /api/commits/:packagePath`);
-      console.log(`   - GET  /api/health/packages`);
-      console.log(`   - PUT  /api/config/files/:id`);
-      console.log(`   - GET  /api/config/files`);
-    });
-
-    server.on('error', (err: any) => {
-      // Handle common errors like EADDRINUSE (port already in use)
-      if (err.code === 'EADDRINUSE') {
-        console.error(
-          `Error: Port ${validatedPort} is already in use. Please specify a different port.`
-        );
-        process.exit(1);
-      } else if (err.code === 'EACCES') {
-        console.error(
-          `Error: Permission denied to listen on port ${validatedPort}. Use a port above 1024.`
-        );
-        process.exit(1);
-      } else {
-        console.error('Server failed to start:', err.message);
-        process.exit(1);
-      }
-    });
-
-    // Graceful shutdown
-    process.on('SIGTERM', () => {
-      console.log('SIGTERM signal received: closing HTTP server');
-      server.close(() => {
-        console.log('HTTP server closed');
-        process.exit(0);
-      });
-    });
-  } catch (error: any) {
-    console.error('Failed to start server:', error.message);
-    process.exit(1);
-  }
-}
-
-export function serveDashboard(
-  rootPath: string
-): void {
-  try {
-    const port = appConfig.dashboard.port;
-    const host = appConfig.dashboard.host;
-    const validatedPort = validatePort(port);
-    const app = express();
-
-    // Security middleware
-    const serverHost = appConfig.server.host === '0.0.0.0' ? 'localhost' : appConfig.server.host;
-    const apiUrl = process.env.API_URL || `http://${serverHost}:${appConfig.server.port}`;
-    app.use(helmet({
-      contentSecurityPolicy: {
-        directives: {
-          defaultSrc: ["'self'"],
-          connectSrc: ["'self'", apiUrl, 'http://localhost:*', 'http://127.0.0.1:*'],
-          scriptSrc: ["'self'"],
-          imgSrc: ["'self'", 'data:', 'https:'],
-        },
-      },
-    }));
-
-    // Strict CORS for dashboard
-    app.use(cors({
-      origin: false, // Don't allow any origin for static assets
-    }));
-
-    // Set request timeout
-    app.use((req, res, next) => {
-      req.setTimeout(30000);
-      res.setTimeout(30000);
-      next();
-    });
-
-    app.get('/env-config.js', (req, res) => {
-      res.setHeader('Content-Type', 'application/javascript');
-      res.setHeader('Cache-Control', 'private, no-cache, no-store, must-revalidate');
-
-      const serverHost = appConfig.server.host === '0.0.0.0' ? 'localhost' : appConfig.server.host;
-      const apiUrl = process.env.API_URL || `http://${serverHost}:${appConfig.server.port}`;
-      res.send(
-        `window.ENV = { API_URL: "${apiUrl}" };`
-      );
-    });
-
-    // This code makes sure that any request that does not matches a static file
-    // in the build folder, will just serve index.html. Client side routing is
-    // going to make sure that the correct content will be loaded.
-    app.use((req, res, next) => {
-      if (/(.ico|.js|.css|.jpg|.png|.map|.woff|.woff2|.ttf)$/i.test(req.path)) {
-        next();
-      } else {
-        res.header(
-          'Cache-Control',
-          'private, no-cache, no-store, must-revalidate'
-        );
-        res.header('Expires', '-1');
-        res.header('Pragma', 'no-cache');
-        res.sendFile('index.html', {
-          root: path.resolve(__dirname, '..', 'monodog-dashboard', 'dist'),
-        }, (err) => {
-          if (err) {
-            console.error('Error serving index.html:', err.message);
-            res.status(500).json({ error: 'Internal server error' });
-          }
-        });
-      }
-    });
-
-    const staticPath = path.join(__dirname, '..', 'monodog-dashboard', 'dist');
-    console.log('Serving static files from:', staticPath);
-    app.use(express.static(staticPath, {
-      maxAge: '1d',
-      etag: false,
-      dotfiles: 'deny', // Don't serve dot files
-    }));
-
-    // Global error handler
-    app.use(errorHandler);
-
-    const server = app.listen(validatedPort, host, () => {
-      console.log(`Dashboard listening on http://${host}:${validatedPort}`);
-      console.log('Press Ctrl+C to quit.');
-    });
-
-    server.on('error', (err: any) => {
-      if (err.code === 'EADDRINUSE') {
-        console.error(`Error: Port ${validatedPort} is already in use.`);
-        process.exit(1);
-      } else if (err.code === 'EACCES') {
-        console.error(`Error: Permission denied to listen on port ${validatedPort}.`);
-        process.exit(1);
-      } else {
-        console.error('Server failed to start:', err.message);
-        process.exit(1);
-      }
-    });
-
-    // Graceful shutdown
-    process.on('SIGTERM', () => {
-      console.log('SIGTERM signal received: closing dashboard server');
-      server.close(() => {
-        console.log('Dashboard server closed');
-        process.exit(0);
-      });
-    });
-  } catch (error: any) {
-    console.error('Failed to start dashboard:', error.message);
-    process.exit(1);
-  }
-}
+/**
+ * Monodog Application Entry Point
+ *
+ * This file exports the main server and dashboard startup functions
+ * All middleware, security, and error handling logic has been moved to separate files
+ */
+
+export { startServer } from './middleware/server-startup';
+export { serveDashboard } from './middleware/dashboard-startup';

package/src/middleware/dashboard-startup.ts

@@ -0,0 +1,149 @@
+/**
+ * Dashboard server startup logic
+ */
+
+import express from 'express';
+import path from 'path';
+import type { Express } from 'express';
+import { httpLogger, AppLogger } from './logger';
+
+import { appConfig } from '../config-loader';
+import {
+  errorHandler,
+} from './error-handler';
+import {
+  createHelmetMiddleware,
+  createDashboardCorsMiddleware,
+  createTimeoutMiddleware,
+  buildApiUrl,
+} from './security';
+
+// Security constants
+const PORT_MIN = 1024;
+const PORT_MAX = 65535;
+
+/**
+ * Validate port number
+ */
+function validatePort(port: string | number): number {
+  const portNum = typeof port === 'string' ? parseInt(port, 10) : port;
+
+  if (isNaN(portNum) || portNum < PORT_MIN || portNum > PORT_MAX) {
+    throw new Error(`Port must be between ${PORT_MIN} and ${PORT_MAX}`);
+  }
+
+  return portNum;
+}
+
+/**
+ * Create Express app for dashboard with middleware
+ */
+function createDashboardApp(): Express {
+  const app = express();
+
+  // Timeout middleware
+  app.use(createTimeoutMiddleware());
+
+  // Security setup
+  const serverHost = appConfig.server.host === '0.0.0.0'
+    ? 'localhost'
+    : appConfig.server.host;
+  const apiUrl = buildApiUrl(serverHost, appConfig.server.port);
+
+  app.use(createHelmetMiddleware(apiUrl));
+  app.use(createDashboardCorsMiddleware());
+
+  // Environment config endpoint
+  app.get('/env-config.js', (_req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    res.setHeader('Cache-Control', 'private, no-cache, no-store, must-revalidate');
+
+    res.send(
+      `window.ENV = { API_URL: "${apiUrl}" };`
+    );
+  });
+
+  // Request logging
+  app.use(httpLogger);
+  // app.use(requestLogger);
+
+  // SPA routing: serve index.html for non-static routes
+  app.use((_req, _res, next) => {
+    if (/(.ico|.js|.css|.jpg|.png|.map|.woff|.woff2|.ttf)$/i.test(_req.path)) {
+      next();
+    } else {
+      _res.header(
+        'Cache-Control',
+        'private, no-cache, no-store, must-revalidate'
+      );
+      _res.header('Expires', '-1');
+      _res.header('Pragma', 'no-cache');
+      _res.sendFile('index.html', {
+        root: path.resolve(__dirname, '..', '..', 'monodog-dashboard', 'dist'),
+      }, (err: Error | null) => {
+        if (err) {
+          AppLogger.error('Error serving index.html:', err);
+          _res.status(500).json({ error: 'Internal server error' });
+        }
+      });
+    }
+  });
+
+  // Static files
+  const staticPath = path.join(__dirname, '..', '..', 'monodog-dashboard', 'dist');
+  AppLogger.debug('Serving static files from:', { path: staticPath });
+  app.use(express.static(staticPath, {
+    maxAge: '1d',
+    etag: false,
+    dotfiles: 'deny',
+  }));
+
+  // Global error handler (must be last)
+  app.use(errorHandler);
+
+  return app;
+}
+
+/**
+ * Start the dashboard server
+ */
+export function serveDashboard(rootPath: string): void {
+  try {
+    const port = appConfig.dashboard.port;
+    const host = appConfig.dashboard.host;
+    const validatedPort = validatePort(port);
+
+    const app = createDashboardApp();
+
+    const server = app.listen(validatedPort, host, () => {
+      console.log(`Dashboard listening on http://${host}:${validatedPort}`);
+      console.log('Press Ctrl+C to quit.');
+    });
+
+    server.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE') {
+        AppLogger.error(`Port ${validatedPort} is already in use.`, err);
+        process.exit(1);
+      } else if (err.code === 'EACCES') {
+        AppLogger.error(`Permission denied to listen on port ${validatedPort}.`, err);
+        process.exit(1);
+      } else {
+        AppLogger.error('Server failed to start:', err);
+        process.exit(1);
+      }
+    });
+
+    // Graceful shutdown
+    process.on('SIGTERM', () => {
+      AppLogger.info('SIGTERM signal received: closing dashboard server');
+      server.close(() => {
+        AppLogger.info('Dashboard server closed');
+        process.exit(0);
+      });
+    });
+  } catch (error: unknown) {
+    const err = error as Error & { message?: string };
+    AppLogger.error('Failed to start dashboard:', err);
+    process.exit(1);
+  }
+}

package/src/middleware/error-handler.ts

@@ -0,0 +1,50 @@
+/**
+ * Error handling middleware for Express
+ */
+
+import { Request, Response, NextFunction, ErrorRequestHandler } from 'express';
+import { AppLogger } from './logger';
+
+/**
+ * Custom error interface extending Error
+ */
+export interface CustomError extends Error {
+  status?: number;
+  statusCode?: number;
+}
+
+/**
+ * Global error handler middleware
+ * Must be registered last in the middleware chain
+ */
+export const errorHandler: ErrorRequestHandler = (
+  err: CustomError,
+  req: Request,
+  res: Response,
+  _next: NextFunction
+): void => {
+  const status = err.status || err.statusCode || 500;
+
+  AppLogger.error('Request error occurred', {
+    status,
+    method: req.method,
+    path: req.path,
+    message: err.message,
+    timestamp: new Date().toISOString(),
+  });
+
+  res.status(status).json({
+    error: 'Internal server error',
+    timestamp: Date.now(),
+  });
+};
+
+/**
+ * 404 Not Found handler
+ */
+export const notFoundHandler = (_req: Request, res: Response): void => {
+  res.status(404).json({
+    error: 'Endpoint not found',
+    timestamp: Date.now(),
+  });
+};

package/src/middleware/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Middleware exports
+ */
+
+export { errorHandler, notFoundHandler } from './error-handler';
+export type { CustomError } from './error-handler';
+
+export {
+  createHelmetMiddleware,
+  createApiCorsMiddleware,
+  createDashboardCorsMiddleware,
+  createTimeoutMiddleware,
+  buildApiUrl,
+  buildDashboardUrl,
+} from './security';
+
+export { startServer } from './server-startup';
+export { serveDashboard } from './dashboard-startup';
+
+export { httpLogger, AppLogger } from './logger';

package/src/middleware/logger.ts

@@ -0,0 +1,58 @@
+/**
+ * Logger configuration using Morgan
+ */
+
+import morgan from 'morgan';
+
+/**
+ * HTTP request logger middleware using Morgan
+ */
+export const httpLogger = morgan('dev');
+
+/**
+ * Application logger for non-HTTP events
+ */
+export class AppLogger {
+  private static readonly prefix = '[APP]';
+
+  static info(message: string, data?: Record<string, unknown>): void {
+    if (process.env.LOG_LEVEL == 'info' || process.env.LOG_LEVEL == 'debug') {
+      if (data) {
+        console.log(`${this.prefix} [INFO]`, message, JSON.stringify(data, null, 2));
+      } else {
+        console.log(`${this.prefix} [INFO]`, message);
+      }
+    }
+  }
+
+  static error(message: string, error?: Error | Record<string, unknown>): void {
+    if (error instanceof Error) {
+      console.error(`${this.prefix} [ERROR]`, message, {
+        message: error.message,
+        stack: error.stack,
+      });
+    } else if (error) {
+      console.error(`${this.prefix} [ERROR]`, message, error);
+    } else {
+      console.error(`${this.prefix} [ERROR]`, message);
+    }
+  }
+
+  static warn(message: string, data?: Record<string, unknown>): void {
+    if (data) {
+      console.warn(`${this.prefix} [WARN]`, message, JSON.stringify(data, null, 2));
+    } else {
+      console.warn(`${this.prefix} [WARN]`, message);
+    }
+  }
+
+  static debug(message: string, data?: Record<string, unknown>): void {
+    if (process.env.LOG_LEVEL == 'debug') {
+      if (data) {
+        console.log(`${this.prefix} [DEBUG]`, message, JSON.stringify(data, null, 2));
+      } else {
+        console.log(`${this.prefix} [DEBUG]`, message);
+      }
+    }
+  }
+}

package/src/middleware/security.ts

@@ -0,0 +1,81 @@
+/**
+ * Security middleware and configuration
+ */
+
+import { Request, Response, NextFunction } from 'express';
+import helmet from 'helmet';
+import cors, { CorsOptions } from 'cors';
+import type { MonodogConfig } from '../types/config';
+
+/**
+ * Create Helmet security middleware with Content Security Policy
+ */
+export function createHelmetMiddleware(apiUrl: string) {
+  return helmet({
+    contentSecurityPolicy: {
+      directives: {
+        defaultSrc: ["'self'"],
+        connectSrc: ["'self'", apiUrl, 'http://localhost:*', 'http://127.0.0.1:*'],
+        scriptSrc: ["'self'"],
+        imgSrc: ["'self'", 'data:', 'https:'],
+      },
+    },
+  });
+}
+
+/**
+ * Create CORS middleware for API server
+ */
+export function createApiCorsMiddleware(dashboardUrl: string) {
+  const corsOptions: CorsOptions = {
+    origin: dashboardUrl,
+    credentials: true,
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+  };
+
+  return cors(corsOptions);
+}
+
+/**
+ * Create CORS middleware for dashboard (no cross-origin)
+ */
+export function createDashboardCorsMiddleware() {
+  const corsOptions: CorsOptions = {
+    origin: false, // Don't allow any origin for static assets
+  };
+
+  return cors(corsOptions);
+}
+
+/**
+ * Request timeout middleware (30 seconds)
+ */
+export function createTimeoutMiddleware() {
+  return (req: Request, res: Response, next: NextFunction): void => {
+    req.setTimeout(30000);
+    res.setTimeout(30000);
+    next();
+  };
+}
+
+/**
+ * Build API URL based on config
+ */
+export function buildApiUrl(
+  host: string,
+  port: number
+): string {
+  const apiHost = host === '0.0.0.0' ? 'localhost' : host;
+  return  `http://${apiHost}:${port}`;
+}
+
+/**
+ * Build dashboard URL based on config
+ */
+export function buildDashboardUrl(config: MonodogConfig): string {
+  const dashboardHost = config.dashboard.host === '0.0.0.0'
+    ? 'localhost'
+    : config.dashboard.host;
+  return `http://${dashboardHost}:${config.dashboard.port}`;
+}