@manojkmfsi/monodog 1.0.1

package/dist/index.js

@@ -0,0 +1,1370 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanner = void 0;
+exports.startServer = startServer;
+exports.serveDashboard = serveDashboard;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const body_parser_1 = require("body-parser");
+const monorepo_scanner_1 = require("./utils/monorepo-scanner");
+exports.scanner = new monorepo_scanner_1.MonorepoScanner();
+const ci_status_1 = require("./utils/ci-status");
+const utilities_1 = require("./utils/utilities");
+const helpers_1 = require("./utils/helpers");
+// Fallback import to handle environments where PrismaClient isn't a named export
+const PrismaPkg = __importStar(require("@prisma/client"));
+const PrismaClient = PrismaPkg.PrismaClient || PrismaPkg.default || PrismaPkg;
+// Import the validateConfig function from your utils
+// import { validateConfig } from '../../apps/dashboard/src/components/modules/config-inspector/utils/config.utils';
+const gitService_1 = require("./gitService");
+const config_loader_1 = require("./config-loader");
+// const appConfig = loadConfig();
+const prisma = new PrismaClient();
+// The main function exported and called by the CLI
+function startServer(rootPath, port, host) {
+    const app = (0, express_1.default)();
+    // --- Middleware ---
+    // 1. Logging Middleware
+    app.use((_req, _res, next) => {
+        console.log(`[SERVER] ${_req.method} ${_req.url} (Root: ${rootPath})`);
+        next();
+    });
+    app.use((0, cors_1.default)());
+    app.use((0, body_parser_1.json)());
+    // Health check
+    app.get('/api/health', (_, res) => {
+        res.json({
+            status: 'ok',
+            timestamp: Date.now(),
+            version: '1.0.0',
+            services: {
+                scanner: 'active',
+                ci: 'active',
+                database: 'active',
+            },
+        });
+    });
+    // Get all packages from database (DONE)
+    app.get('/api/packages', async (_req, res) => {
+        try {
+            // Try to get packages from database first
+            let dbPackages = await prisma.package.findMany();
+            if (!dbPackages.length) {
+                try {
+                    const rootDir = rootPath;
+                    console.log('rootDir -->', rootDir);
+                    const packages = (0, utilities_1.scanMonorepo)(rootDir);
+                    console.log('packages --> scan', packages.length);
+                    for (const pkg of packages) {
+                        await (0, helpers_1.storePackage)(pkg);
+                    }
+                }
+                catch (error) {
+                    throw new Error('Error ' + error);
+                }
+                dbPackages = await prisma.package.findMany();
+            }
+            const transformedPackages = dbPackages.map((pkg) => {
+                // We create a new object 'transformedPkg' based on the database record 'pkg'
+                const transformedPkg = { ...pkg };
+                // 1. Maintainers (Your Logic)
+                transformedPkg.maintainers = pkg.maintainers
+                    ? JSON.parse(pkg.maintainers)
+                    : [];
+                // 2. Tags
+                // transformedPkg.tags = pkg.tags
+                //     ? JSON.parse(pkg.tags)
+                //     : [];
+                // 3. Scripts/repository (should default to an object, not an array)
+                transformedPkg.scripts = pkg.scripts ? JSON.parse(pkg.scripts) : {};
+                transformedPkg.repository = pkg.repository
+                    ? JSON.parse(pkg.repository)
+                    : {};
+                // 4. Dependencies List
+                transformedPkg.dependencies = pkg.dependencies
+                    ? JSON.parse(pkg.dependencies)
+                    : [];
+                transformedPkg.devDependencies = pkg.devDependencies
+                    ? JSON.parse(pkg.devDependencies)
+                    : [];
+                transformedPkg.peerDependencies = pkg.peerDependencies
+                    ? JSON.parse(pkg.peerDependencies)
+                    : [];
+                return transformedPkg; // Return the fully transformed object
+            });
+            res.json(transformedPackages);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch packages, ' + error });
+        }
+    });
+    app.get('/api/packages/refresh', async (_req, res) => {
+        try {
+            await prisma.package.deleteMany();
+            const rootDir = rootPath;
+            const packages = (0, utilities_1.scanMonorepo)(rootDir);
+            console.log('packages -->', packages.length);
+            for (const pkg of packages) {
+                await (0, helpers_1.storePackage)(pkg);
+            }
+            res.json(packages);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to refresh packages' });
+        }
+    });
+    // Get package details
+    app.get('/api/packages/:name', async (_req, res) => {
+        try {
+            const { name } = _req.params;
+            const pkg = await prisma.package.findUnique({
+                where: {
+                    name: name,
+                },
+                include: {
+                    dependenciesInfo: true,
+                    commits: true,
+                    packageHealth: true,
+                },
+            });
+            if (!pkg) {
+                return res.status(404).json({ error: 'Package not found' });
+            }
+            const transformedPkg = { ...pkg };
+            // --- APPLY PARSING TO EACH FIELD ---
+            // 1. Maintainers (Your Logic)
+            // transformedPkg.maintainers = pkg.maintainers
+            //   ? JSON.parse(pkg.maintainers)
+            //   : [];
+            // 2. Tags
+            // transformedPkg.tags = pkg.tags
+            //     ? JSON.parse(pkg.tags)
+            //     : [];
+            // 3. Scripts/repository (should default to an object, not an array)
+            transformedPkg.scripts = pkg.scripts ? JSON.parse(pkg.scripts) : {};
+            transformedPkg.repository = pkg.repository
+                ? JSON.parse(pkg.repository)
+                : {};
+            // 4. Dependencies List
+            transformedPkg.dependencies = pkg.dependencies
+                ? JSON.parse(pkg.dependencies)
+                : [];
+            transformedPkg.devDependencies = pkg.devDependencies
+                ? JSON.parse(pkg.devDependencies)
+                : [];
+            transformedPkg.peerDependencies = pkg.peerDependencies
+                ? JSON.parse(pkg.peerDependencies)
+                : [];
+            // Get additional package information
+            const reports = await (0, monorepo_scanner_1.generateReports)();
+            const packageReport = reports.find((r) => r.package.name === name);
+            const result = {
+                ...transformedPkg,
+                report: packageReport,
+                ciStatus: await ci_status_1.ciStatusManager.getPackageStatus(name),
+            };
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch package details' });
+        }
+    });
+    // Get commit details
+    app.get('/api/commits/:packagePath', async (_req, res) => {
+        try {
+            const { packagePath } = _req.params;
+            // Decode the package path
+            const decodedPath = decodeURIComponent(packagePath);
+            console.log('🔍 Fetching commits for path:', decodedPath);
+            console.log('📁 Current working directory:', process.cwd());
+            const gitService = new gitService_1.GitService();
+            // Check if this is an absolute path and convert to relative if needed
+            let relativePath = decodedPath;
+            const projectRoot = process.cwd();
+            // If it's an absolute path, make it relative to project root
+            if (path_1.default.isAbsolute(decodedPath)) {
+                relativePath = path_1.default.relative(projectRoot, decodedPath);
+                console.log('🔄 Converted absolute path to relative:', relativePath);
+            }
+            // Check if the path exists
+            try {
+                await fs_1.default.promises.access(relativePath);
+                console.log('✅ Path exists:', relativePath);
+            }
+            catch (fsError) {
+                console.log('❌ Path does not exist:', relativePath);
+                // Try the original path as well
+                try {
+                    await fs_1.default.promises.access(decodedPath);
+                    console.log('✅ Original path exists:', decodedPath);
+                    relativePath = decodedPath; // Use original path if it exists
+                }
+                catch (secondError) {
+                    return res.status(404).json({
+                        error: `Package path not found: ${relativePath} (also tried: ${decodedPath})`,
+                    });
+                }
+            }
+            const commits = await gitService.getAllCommits(relativePath);
+            console.log(`✅ Successfully fetched ${commits.length} commits for ${relativePath}`);
+            res.json(commits);
+        }
+        catch (error) {
+            console.error('💥 Error fetching commit details:', error);
+            res.status(500).json({
+                error: 'Failed to fetch commit details',
+                message: error.message,
+                stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
+            });
+        }
+    });
+    // Get dependency graph
+    // app.get('/api/graph', async (_req, res) => {
+    //   try {
+    //     const packages = scanMonorepo(process.cwd());
+    //     const graph = generateDependencyGraph(packages);
+    //     const circularDeps = findCircularDependencies(packages);
+    //     res.json({
+    //       ...graph,
+    //       circularDependencies: circularDeps,
+    //       metadata: {
+    //         totalNodes: graph.nodes.length,
+    //         totalEdges: graph.edges.length,
+    //         circularDependencies: circularDeps.length,
+    //       },
+    //     });
+    //   } catch (error) {
+    //     res.status(500).json({ error: 'Failed to generate dependency graph' });
+    //   }
+    // });
+    // Get monorepo statistics
+    app.get('/api/stats', async (_req, res) => {
+        try {
+            const packages = (0, utilities_1.scanMonorepo)(process.cwd());
+            const stats = (0, utilities_1.generateMonorepoStats)(packages);
+            res.json({
+                ...stats,
+                timestamp: Date.now(),
+                scanDuration: 0, // Would be calculated from actual scan
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch statistics' });
+        }
+    });
+    // Get CI status for all packages
+    app.get('/api/ci/status', async (_req, res) => {
+        try {
+            const packages = (0, utilities_1.scanMonorepo)(process.cwd());
+            const ciStatus = await (0, ci_status_1.getMonorepoCIStatus)(packages);
+            res.json(ciStatus);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch CI status' });
+        }
+    });
+    // Get CI status for specific package
+    app.get('/api/ci/packages/:name', async (_req, res) => {
+        try {
+            const { name } = _req.params;
+            const status = await ci_status_1.ciStatusManager.getPackageStatus(name);
+            if (!status) {
+                return res.status(404).json({ error: 'Package CI status not found' });
+            }
+            res.json(status);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch package CI status' });
+        }
+    });
+    // Trigger CI build for package
+    app.post('/api/ci/trigger', async (_req, res) => {
+        try {
+            const { packageName, providerName, branch } = _req.body;
+            if (!packageName) {
+                return res.status(400).json({ error: 'Package name is required' });
+            }
+            const result = await ci_status_1.ciStatusManager.triggerBuild(packageName, providerName || 'github', branch || 'main');
+            if (result.success) {
+                res.json({
+                    success: true,
+                    buildId: result.buildId,
+                    message: `Build triggered for ${packageName}`,
+                });
+            }
+            else {
+                res.status(400).json({
+                    success: false,
+                    error: result.error,
+                });
+            }
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to trigger build' });
+        }
+    });
+    // Get build logs
+    app.get('/api/ci/builds/:buildId/logs', async (_req, res) => {
+        try {
+            const { buildId } = _req.params;
+            const { provider } = _req.query;
+            if (!provider) {
+                return res.status(400).json({ error: 'Provider is required' });
+            }
+            const logs = await ci_status_1.ciStatusManager.getBuildLogs(buildId, provider);
+            res.json({ buildId, logs });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch build logs' });
+        }
+    });
+    // Get build artifacts
+    app.get('/api/ci/builds/:buildId/artifacts', async (_req, res) => {
+        try {
+            const { buildId } = _req.params;
+            const { provider } = _req.query;
+            if (!provider) {
+                return res.status(400).json({ error: 'Provider is required' });
+            }
+            const artifacts = await ci_status_1.ciStatusManager.getBuildArtifacts(buildId, provider);
+            res.json({ buildId, artifacts });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch build artifacts' });
+        }
+    });
+    // Perform full monorepo scan
+    app.post('/api/scan', async (_req, res) => {
+        try {
+            const { force } = _req.body;
+            if (force) {
+                exports.scanner.clearCache();
+            }
+            const result = await (0, monorepo_scanner_1.quickScan)();
+            res.json({
+                success: true,
+                message: 'Scan completed successfully',
+                result,
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                success: false,
+                error: 'Failed to perform scan',
+            });
+        }
+    });
+    // Get scan results
+    app.get('/api/scan/results', async (_req, res) => {
+        try {
+            const result = await (0, monorepo_scanner_1.quickScan)();
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch scan results' });
+        }
+    });
+    // Export scan results
+    app.get('/api/scan/export/:format', async (_req, res) => {
+        try {
+            const { format } = _req.params;
+            const { filename } = _req.query;
+            if (!['json', 'csv', 'html'].includes(format)) {
+                return res.status(400).json({ error: 'Invalid export format' });
+            }
+            const result = await (0, monorepo_scanner_1.quickScan)();
+            const exportData = exports.scanner.exportResults(result, format);
+            if (format === 'json') {
+                res.json(result);
+            }
+            else {
+                const contentType = format === 'csv' ? 'text/csv' : 'text/html';
+                const contentDisposition = filename
+                    ? `attachment; filename="${filename}"`
+                    : `attachment; filename="monorepo-scan.${format}"`;
+                res.setHeader('Content-Type', contentType);
+                res.setHeader('Content-Disposition', contentDisposition);
+                res.send(exportData);
+            }
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to export scan results' });
+        }
+    });
+    // ---------- HEALTH --------------------
+    // Get package health metrics
+    app.get('/api/health/packages/:name', async (_req, res) => {
+        try {
+            console.log('_req.params -->', _req.params);
+            const { name } = _req.params;
+            const packages = (0, utilities_1.scanMonorepo)(process.cwd());
+            const packageInfo = packages.find(p => p.name === name);
+            if (!packageInfo) {
+                return res.status(404).json({ error: 'Package not found' });
+            }
+            // Get health metrics (mock data for now)
+            const health = {
+                buildStatus: 'success',
+                testCoverage: Math.floor(Math.random() * 100),
+                lintStatus: 'pass',
+                securityAudit: 'pass',
+                overallScore: Math.floor(Math.random() * 40) + 60,
+                lastUpdated: new Date(),
+            };
+            res.json({
+                packageName: name,
+                health,
+                size: {
+                    size: Math.floor(Math.random() * 1024 * 1024), // Random size
+                    files: Math.floor(Math.random() * 1000),
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch health metrics' });
+        }
+    });
+    // Get all package health metrics
+    // app.get('/api/health/packages', async (_req, res) => {
+    //   try {
+    //     // Try to get health data from database
+    //     const healthData = await prisma.healthStatus.findMany();
+    //     console.log('healthData -->', healthData);
+    //     // Transform the data to match the expected frontend format
+    //     const transformedHealthData = healthData.map(health => {
+    //       const transformedHealth = { ...health };
+    //       // Parse any JSON fields that were stored as strings
+    //       if (health.metrics) {
+    //         transformedHealth.metrics = JSON.parse(health.metrics);
+    //       } else {
+    //         transformedHealth.metrics = [];
+    //       }
+    //       if (health.packageHealth) {
+    //         transformedHealth.packageHealth = JSON.parse(health.packageHealth);
+    //       } else {
+    //         transformedHealth.packageHealth = [];
+    //       }
+    //       // Ensure we have all required fields with defaults
+    //       return {
+    //         id: transformedHealth.id,
+    //         overallScore: transformedHealth.overallScore || 0,
+    //         metrics: transformedHealth.metrics || [],
+    //         packageHealth: transformedHealth.packageHealth || [],
+    //         createdAt: transformedHealth.createdAt,
+    //         updatedAt: transformedHealth.updatedAt,
+    //       };
+    //     });
+    //     // Return the latest health data (you might want to sort by createdAt desc)
+    //     const latestHealthData = transformedHealthData.sort(
+    //       (a, b) => new Date(b.createdAt) - new Date(a.createdAt)
+    //     )[0] || {
+    //       overallScore: 0,
+    //       metrics: [],
+    //       packageHealth: [],
+    //     };
+    //     res.json(latestHealthData);
+    //   } catch (error) {
+    //     console.error('Error fetching health data:', error);
+    //     res.status(500).json({ error: 'Failed to fetch health data' });
+    //   }
+    // });
+    app.get('/api/health/packages', async (_req, res) => {
+        try {
+            // Fetch all package health data from database
+            const packageHealthData = await prisma.packageHealth.findMany();
+            console.log('packageHealthData -->', packageHealthData.length);
+            // Transform the data to match the expected frontend format
+            const packages = packageHealthData.map((pkg) => {
+                const health = {
+                    buildStatus: pkg.packageBuildStatus,
+                    testCoverage: pkg.packageTestCoverage,
+                    lintStatus: pkg.packageLintStatus,
+                    securityAudit: pkg.packageSecurity,
+                    overallScore: pkg.packageOverallScore,
+                };
+                return {
+                    packageName: pkg.packageName,
+                    health: health,
+                    isHealthy: pkg.packageOverallScore >= 80,
+                };
+            });
+            // Calculate summary statistics
+            const total = packages.length;
+            const healthy = packages.filter((pkg) => pkg.isHealthy).length;
+            const unhealthy = packages.filter((pkg) => !pkg.isHealthy).length;
+            const averageScore = packages.length > 0
+                ? packages.reduce((sum, pkg) => sum + pkg.health.overallScore, 0) /
+                    packages.length
+                : 0;
+            const response = {
+                packages: packages,
+                summary: {
+                    total: total,
+                    healthy: healthy,
+                    unhealthy: unhealthy,
+                    averageScore: averageScore,
+                },
+            };
+            console.log('Transformed health data -->', response.summary);
+            res.json(response);
+        }
+        catch (error) {
+            console.error('Error fetching health data from database:', error);
+            res
+                .status(500)
+                .json({ error: 'Failed to fetch health data from database' });
+        }
+    });
+    app.get('/api/health/refresh', async (_req, res) => {
+        try {
+            const rootDir = rootPath;
+            const packages = (0, utilities_1.scanMonorepo)(rootDir);
+            console.log('packages -->', packages.length);
+            const healthMetrics = await Promise.all(packages.map(async (pkg) => {
+                try {
+                    // Await each health check function since they return promises
+                    const buildStatus = await (0, monorepo_scanner_1.funCheckBuildStatus)(pkg);
+                    const testCoverage = await (0, monorepo_scanner_1.funCheckTestCoverage)(pkg);
+                    const lintStatus = await (0, monorepo_scanner_1.funCheckLintStatus)(pkg);
+                    const securityAudit = await (0, monorepo_scanner_1.funCheckSecurityAudit)(pkg);
+                    // Calculate overall health score
+                    const overallScore = (0, utilities_1.calculatePackageHealth)(buildStatus, testCoverage, lintStatus, securityAudit);
+                    const health = {
+                        buildStatus: buildStatus,
+                        testCoverage: testCoverage,
+                        lintStatus: lintStatus,
+                        securityAudit: securityAudit,
+                        overallScore: overallScore.overallScore,
+                    };
+                    const packageStatus = health.overallScore >= 80
+                        ? 'healthy'
+                        : health.overallScore >= 60 && health.overallScore < 80
+                            ? 'warning'
+                            : 'error';
+                    console.log(pkg.name, '-->', health, packageStatus);
+                    // FIX: Use upsert to handle existing packages and proper Prisma syntax
+                    await prisma.packageHealth.upsert({
+                        where: {
+                            packageName: pkg.name,
+                        },
+                        update: {
+                            packageOverallScore: overallScore.overallScore,
+                            packageBuildStatus: buildStatus,
+                            packageTestCoverage: testCoverage,
+                            packageLintStatus: lintStatus,
+                            packageSecurity: securityAudit,
+                            packageDependencies: '',
+                            updatedAt: new Date(),
+                            // package: {
+                            //   update: {
+                            //     where: { name: pkg.name },
+                            //     data: { status: packageStatus },
+                            //   },
+                            // },
+                        },
+                        create: {
+                            packageName: pkg.name,
+                            packageOverallScore: overallScore.overallScore,
+                            packageBuildStatus: buildStatus,
+                            packageTestCoverage: testCoverage,
+                            packageLintStatus: lintStatus,
+                            packageSecurity: securityAudit,
+                            packageDependencies: '',
+                        },
+                    });
+                    // update related package status as well
+                    await prisma.package.update({
+                        where: { name: pkg.name },
+                        data: { status: packageStatus },
+                    });
+                    return {
+                        packageName: pkg.name,
+                        health,
+                        isHealthy: health.overallScore >= 80,
+                    };
+                }
+                catch (error) {
+                    return {
+                        packageName: pkg.name,
+                        health: {
+                            "buildStatus": "",
+                            "testCoverage": 0,
+                            "lintStatus": "",
+                            "securityAudit": "",
+                            "overallScore": 0
+                        },
+                        isHealthy: false,
+                        error: 'Failed to fetch health metrics1',
+                    };
+                }
+            }));
+            res.json({
+                packages: healthMetrics.filter(h => !h.error),
+                summary: {
+                    total: packages.length,
+                    healthy: healthMetrics.filter(h => h.isHealthy).length,
+                    unhealthy: healthMetrics.filter(h => !h.isHealthy).length,
+                    averageScore: healthMetrics
+                        .filter(h => h.health)
+                        .reduce((sum, h) => sum + h.health.overallScore, 0) /
+                        healthMetrics.filter(h => h.health).length,
+                },
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch health metrics' });
+        }
+    });
+    // function calculateHealthStatus(
+    //   healthy: number,
+    //   total: number
+    // ): 'healthy' | 'warning' | 'error' {
+    //   if (total === 0) return 'healthy';
+    //   const ratio = healthy / total;
+    //   if (ratio >= 0.8) return 'healthy';
+    //   if (ratio >= 0.6) return 'warning';
+    //   return 'error';
+    // }
+    // Search packages
+    app.get('/api/search', async (_req, res) => {
+        try {
+            const { q: query, type, status } = _req.query;
+            const packages = (0, utilities_1.scanMonorepo)(process.cwd());
+            let filtered = packages;
+            // Filter by search query
+            if (query) {
+                const searchTerm = query.toLowerCase();
+                filtered = filtered.filter(pkg => pkg.name.toLowerCase().includes(searchTerm) ||
+                    pkg.description?.toLowerCase().includes(searchTerm));
+            }
+            // Filter by type
+            if (type && type !== 'all') {
+                filtered = filtered.filter(pkg => pkg.type === type);
+            }
+            // Filter by status (would need health data)
+            if (status && status !== 'all') {
+                // This would filter by actual health status
+                // For now, just return all packages
+            }
+            res.json({
+                query,
+                results: filtered,
+                total: filtered.length,
+                filters: { type, status },
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to search packages' });
+        }
+    });
+    // Get recent activity
+    app.get('/api/activity', async (_req, res) => {
+        try {
+            const { limit = 20 } = _req.query;
+            const packages = (0, utilities_1.scanMonorepo)(process.cwd());
+            // Mock recent activity data
+            const activities = packages
+                .slice(0, Math.min(Number(limit), packages.length))
+                .map((pkg, index) => ({
+                id: `activity-${Date.now()}-${index}`,
+                type: [
+                    'package_updated',
+                    'build_success',
+                    'test_passed',
+                    'dependency_updated',
+                ][Math.floor(Math.random() * 4)],
+                packageName: pkg.name,
+                message: `Activity for ${pkg.name}`,
+                timestamp: new Date(Date.now() - Math.random() * 7 * 24 * 60 * 60 * 1000), // Random time in last week
+                metadata: {
+                    version: pkg.version,
+                    type: pkg.type,
+                },
+            }));
+            // Sort by timestamp (newest first)
+            activities.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+            res.json({
+                activities: activities.slice(0, Number(limit)),
+                total: activities.length,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to fetch recent activity' });
+        }
+    });
+    // Get system information
+    app.get('/api/system', (_, res) => {
+        res.json({
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            memory: process.memoryUsage(),
+            uptime: process.uptime(),
+            pid: process.pid,
+            cwd: process.cwd(),
+            env: {
+                NODE_ENV: process.env.NODE_ENV,
+                PORT: process.env.PORT,
+            },
+        });
+    });
+    // ------------------------- CONFIGURATION TAB ------------------------- //
+    // Get all configuration files from the file system
+    app.get('/api/config/files', async (_req, res) => {
+        try {
+            // Find the monorepo root instead of using process.cwd()
+            const rootDir = rootPath;
+            console.log('Monorepo root directory:', rootDir);
+            console.log('Backend directory:', __dirname);
+            const configFiles = await scanConfigFiles(rootDir);
+            // Transform to match frontend ConfigFile interface
+            const transformedFiles = configFiles.map(file => ({
+                id: file.id,
+                name: file.name,
+                path: file.path,
+                type: file.type,
+                content: file.content,
+                size: file.size,
+                lastModified: file.lastModified,
+                hasSecrets: file.hasSecrets,
+                isEditable: true,
+                // validation: validateConfig(file.content, file.name),
+            }));
+            res.json({
+                success: true,
+                files: transformedFiles,
+                total: transformedFiles.length,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            console.error('Error fetching configuration files:', error);
+            res.status(500).json({
+                success: false,
+                error: 'Failed to fetch configuration files',
+            });
+        }
+    });
+    // Helper function to scan for configuration files
+    async function scanConfigFiles(rootDir) {
+        const configPatterns = [
+            // Root level config files
+            'package.json',
+            'pnpm-workspace.yaml',
+            'pnpm-lock.yaml',
+            'turbo.json',
+            'tsconfig.json',
+            '.eslintrc.*',
+            '.prettierrc',
+            '.prettierignore',
+            '.editorconfig',
+            '.nvmrc',
+            '.gitignore',
+            'commitlint.config.js',
+            '.releaserc.json',
+            'env.example',
+            // App-specific config files
+            'vite.config.*',
+            'tailwind.config.*',
+            'postcss.config.*',
+            'components.json',
+            // Package-specific config files
+            'jest.config.*',
+            '.env*',
+            'dockerfile*',
+        ];
+        const configFiles = [];
+        const scannedPaths = new Set();
+        function scanDirectory(dir, depth = 0) {
+            if (scannedPaths.has(dir) || depth > 8)
+                return; // Limit depth for safety
+            scannedPaths.add(dir);
+            try {
+                const items = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const item of items) {
+                    const fullPath = path_1.default.join(dir, item.name);
+                    if (item.isDirectory()) {
+                        // Skip node_modules and other non-source directories
+                        if (!shouldSkipDirectory(item.name, depth)) {
+                            scanDirectory(fullPath, depth + 1);
+                        }
+                    }
+                    else {
+                        // Check if file matches config patterns
+                        if (isConfigFile(item.name)) {
+                            try {
+                                const stats = fs_1.default.statSync(fullPath);
+                                const content = fs_1.default.readFileSync(fullPath, 'utf8');
+                                const relativePath = fullPath.replace(rootDir, '').replace(/\\/g, '/') ||
+                                    `/${item.name}`;
+                                configFiles.push({
+                                    id: relativePath,
+                                    name: item.name,
+                                    path: relativePath,
+                                    type: getFileType(item.name),
+                                    content: content,
+                                    size: stats.size,
+                                    lastModified: stats.mtime.toISOString(),
+                                    hasSecrets: containsSecrets(content, item.name),
+                                });
+                            }
+                            catch (error) {
+                                console.warn(`Could not read file: ${fullPath}`);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Could not scan directory: ${dir}`);
+            }
+        }
+        function shouldSkipDirectory(dirName, depth) {
+            const skipDirs = [
+                'node_modules',
+                'dist',
+                'build',
+                '.git',
+                '.next',
+                '.vscode',
+                '.turbo',
+                '.husky',
+                '.github',
+                '.vite',
+                'migrations',
+                'coverage',
+                '.cache',
+                'tmp',
+                'temp',
+            ];
+            // At root level, be more permissive
+            if (depth === 0) {
+                return skipDirs.includes(dirName);
+            }
+            // Deeper levels, skip more directories
+            return skipDirs.includes(dirName) || dirName.startsWith('.');
+        }
+        function isConfigFile(filename) {
+            return configPatterns.some(pattern => {
+                if (pattern.includes('*')) {
+                    const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                    return regex.test(filename.toLowerCase());
+                }
+                return filename.toLowerCase() === pattern.toLowerCase();
+            });
+        }
+        console.log(`🔍 Scanning for config files in: ${rootDir}`);
+        // Start scanning from root
+        scanDirectory(rootDir);
+        // Sort files by path for consistent ordering
+        configFiles.sort((a, b) => a.path.localeCompare(b.path));
+        console.log(`📁 Found ${configFiles.length} configuration files`);
+        // Log some sample files for debugging
+        if (configFiles.length > 0) {
+            console.log('Sample config files found:');
+            configFiles.slice(0, 5).forEach(file => {
+                console.log(`  - ${file.path} (${file.type})`);
+            });
+            if (configFiles.length > 5) {
+                console.log(`  ... and ${configFiles.length - 5} more`);
+            }
+        }
+        return configFiles;
+    }
+    function getFileType(filename) {
+        const extension = filename.split('.').pop()?.toLowerCase();
+        switch (extension) {
+            case 'json':
+                return 'json';
+            case 'yaml':
+            case 'yml':
+                return 'yaml';
+            case 'js':
+                return 'javascript';
+            case 'ts':
+                return 'typescript';
+            case 'env':
+                return 'env';
+            case 'md':
+                return 'markdown';
+            case 'cjs':
+                return 'javascript';
+            case 'config':
+                return 'text';
+            case 'example':
+                return filename.includes('.env') ? 'env' : 'text';
+            default:
+                return 'text';
+        }
+    }
+    function containsSecrets(content, filename) {
+        // Only check .env files and files that might contain secrets
+        if (!filename.includes('.env') && !filename.includes('config')) {
+            return false;
+        }
+        const secretPatterns = [
+            /password\s*=\s*[^\s]/i,
+            /secret\s*=\s*[^\s]/i,
+            /key\s*=\s*[^\s]/i,
+            /token\s*=\s*[^\s]/i,
+            /auth\s*=\s*[^\s]/i,
+            /credential\s*=\s*[^\s]/i,
+            /api_key\s*=\s*[^\s]/i,
+            /private_key\s*=\s*[^\s]/i,
+            /DATABASE_URL/i,
+            /JWT_SECRET/i,
+            /GITHUB_TOKEN/i,
+        ];
+        return secretPatterns.some(pattern => pattern.test(content));
+    }
+    // Save configuration file
+    // app.put('/api/config/files/:id', async (_req, res) => {
+    //   try {
+    //     const { id } = _req.params;
+    //     const { content } = _req.body;
+    //     if (!content) {
+    //       return res.status(400).json({
+    //         success: false,
+    //         error: 'Content is required',
+    //       });
+    //     }
+    //     const rootDir = process.cwd();
+    //     const filePath = path.join(rootDir, id.startsWith('/') ? id.slice(1) : id);
+    //     // Security check: ensure the file is within the project directory
+    //     if (!filePath.startsWith(rootDir)) {
+    //       return res.status(403).json({
+    //         success: false,
+    //         error: 'Access denied',
+    //       });
+    //     }
+    //     // Check if file exists and is writable
+    //     try {
+    //       await fs.promises.access(filePath, fs.constants.W_OK);
+    //     } catch (error) {
+    //       return res.status(403).json({
+    //         success: false,
+    //         error: 'File is not writable or does not exist',
+    //       });
+    //     }
+    //     // // Backup the original file (optional but recommended)
+    //     // const backupPath = `${filePath}.backup-${Date.now()}`;
+    //     // try {
+    //     //   await fs.promises.copyFile(filePath, backupPath);
+    //     // } catch (error) {
+    //     //   console.warn('Could not create backup file:', error);
+    //     // }
+    //     // Write the new content
+    //     await fs.promises.writeFile(filePath, content, 'utf8');
+    //     // Get file stats for updated information
+    //     const stats = await fs.promises.stat(filePath);
+    //     const filename = path.basename(filePath);
+    //     const updatedFile = {
+    //       id: id,
+    //       name: filename,
+    //       path: id,
+    //       type: getFileType(filename),
+    //       content: content,
+    //       size: stats.size,
+    //       lastModified: stats.mtime.toISOString(),
+    //       hasSecrets: containsSecrets(content, filename),
+    //       isEditable: true,
+    //       validation: validateConfig(content, filename),
+    //     };
+    //     res.json({
+    //       success: true,
+    //       file: updatedFile,
+    //       message: 'File saved successfully',
+    //       // backupCreated: fs.existsSync(backupPath),
+    //     });
+    //   } catch (error) {
+    //     console.error('Error saving configuration file:', error);
+    //     res.status(500).json({
+    //       success: false,
+    //       error: 'Failed to save configuration file',
+    //     });
+    //   }
+    // });
+    app.put('/api/config/files/:id', async (_req, res) => {
+        try {
+            const { id } = _req.params;
+            const { content } = _req.body;
+            if (!content) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Content is required',
+                });
+            }
+            // Use the monorepo root
+            const rootDir = rootPath;
+            const filePath = path_1.default.join(rootDir, id.startsWith('/') ? id.slice(1) : id);
+            console.log('💾 Saving file:', filePath);
+            console.log('📁 Root directory:', rootDir);
+            // Security check: ensure the file is within the project directory
+            if (!filePath.startsWith(rootDir)) {
+                return res.status(403).json({
+                    success: false,
+                    error: 'Access denied',
+                });
+            }
+            // Check if file exists and is writable
+            try {
+                await fs_1.default.promises.access(filePath, fs_1.default.constants.W_OK);
+            }
+            catch (error) {
+                return res.status(403).json({
+                    success: false,
+                    error: 'File is not writable or does not exist',
+                });
+            }
+            // Write the new content
+            await fs_1.default.promises.writeFile(filePath, content, 'utf8');
+            // Get file stats for updated information
+            const stats = await fs_1.default.promises.stat(filePath);
+            const filename = path_1.default.basename(filePath);
+            const updatedFile = {
+                id: id,
+                name: filename,
+                path: id,
+                type: getFileType(filename),
+                content: content,
+                size: stats.size,
+                lastModified: stats.mtime.toISOString(),
+                hasSecrets: containsSecrets(content, filename),
+                isEditable: true,
+                // validation: validateConfig(content, filename),
+            };
+            res.json({
+                success: true,
+                file: updatedFile,
+                message: 'File saved successfully',
+            });
+        }
+        catch (error) {
+            console.error('Error saving configuration file:', error);
+            res.status(500).json({
+                success: false,
+                error: 'Failed to save configuration file',
+            });
+        }
+    });
+    // Update package configuration with path from frontend - preserving all fields, no backups
+    app.put('/api/packages/update', async (req, res) => {
+        try {
+            const { packageName, config, packagePath } = req.body;
+            if (!packageName || !config || !packagePath) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'Package name, configuration, and package path are required',
+                });
+            }
+            console.log('💾 Updating package configuration for:', packageName);
+            console.log('📁 Package path:', packagePath);
+            // Validate JSON syntax with better error handling
+            let newConfig;
+            try {
+                newConfig = JSON.parse(config);
+            }
+            catch (error) {
+                console.error('JSON parsing error:', error);
+                return res.status(400).json({
+                    success: false,
+                    error: 'Invalid JSON configuration',
+                    message: `JSON parsing error: ${error instanceof Error ? error.message : 'Invalid format'}`,
+                });
+            }
+            const packageJsonPath = path_1.default.join(packagePath, 'package.json');
+            // Security check: ensure the path is valid
+            if (!fs_1.default.existsSync(packagePath)) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'Package directory not found',
+                });
+            }
+            // Check if package.json exists
+            if (!fs_1.default.existsSync(packageJsonPath)) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'package.json not found in the specified directory',
+                });
+            }
+            // Read the existing package.json to preserve all fields
+            const existingContent = await fs_1.default.promises.readFile(packageJsonPath, 'utf8');
+            let existingConfig;
+            try {
+                existingConfig = JSON.parse(existingContent);
+            }
+            catch (error) {
+                return res.status(500).json({
+                    success: false,
+                    error: 'Existing package.json contains invalid JSON',
+                    message: `Error parsing existing package.json: ${error instanceof Error ? error.message : 'Invalid JSON'}`,
+                });
+            }
+            // Merge the new configuration with existing configuration
+            const mergedConfig = {
+                ...existingConfig,
+                name: newConfig.name || existingConfig.name,
+                version: newConfig.version || existingConfig.version,
+                description: newConfig.description !== undefined
+                    ? newConfig.description
+                    : existingConfig.description,
+                license: newConfig.license !== undefined
+                    ? newConfig.license
+                    : existingConfig.license,
+                repository: newConfig.repository || existingConfig.repository,
+                scripts: newConfig.scripts || existingConfig.scripts,
+                dependencies: newConfig.dependencies || existingConfig.dependencies,
+                devDependencies: newConfig.devDependencies || existingConfig.devDependencies,
+                peerDependencies: newConfig.peerDependencies || existingConfig.peerDependencies,
+            };
+            // Write the merged configuration back
+            const formattedConfig = JSON.stringify(mergedConfig, null, 2);
+            await fs_1.default.promises.writeFile(packageJsonPath, formattedConfig, 'utf8');
+            // Update the package in the database - use correct field names based on your Prisma schema
+            const updateData = {
+                // Use 'lastUpdated' instead of 'updatedAt' based on the error message
+                lastUpdated: new Date(),
+            };
+            // Only update fields that exist in your Prisma schema
+            if (newConfig.version)
+                updateData.version = newConfig.version;
+            if (newConfig.description !== undefined)
+                updateData.description = newConfig.description || '';
+            if (newConfig.license !== undefined)
+                updateData.license = newConfig.license || '';
+            if (newConfig.scripts)
+                updateData.scripts = JSON.stringify(newConfig.scripts);
+            if (newConfig.repository)
+                updateData.repository = JSON.stringify(newConfig.repository);
+            if (newConfig.dependencies)
+                updateData.dependencies = JSON.stringify(newConfig.dependencies);
+            if (newConfig.devDependencies)
+                updateData.devDependencies = JSON.stringify(newConfig.devDependencies);
+            if (newConfig.peerDependencies)
+                updateData.peerDependencies = JSON.stringify(newConfig.peerDependencies);
+            console.log('📝 Updating database with:', updateData);
+            const updatedPackage = await prisma.package.update({
+                where: { name: packageName },
+                data: updateData,
+            });
+            // Transform the response
+            const transformedPackage = {
+                ...updatedPackage,
+                maintainers: updatedPackage.maintainers
+                    ? JSON.parse(updatedPackage.maintainers)
+                    : [],
+                scripts: updatedPackage.scripts
+                    ? JSON.parse(updatedPackage.scripts)
+                    : {},
+                repository: updatedPackage.repository
+                    ? JSON.parse(updatedPackage.repository)
+                    : {},
+                dependencies: updatedPackage.dependencies
+                    ? JSON.parse(updatedPackage.dependencies)
+                    : {},
+                devDependencies: updatedPackage.devDependencies
+                    ? JSON.parse(updatedPackage.devDependencies)
+                    : {},
+                peerDependencies: updatedPackage.peerDependencies
+                    ? JSON.parse(updatedPackage.peerDependencies)
+                    : {},
+            };
+            // Return success response
+            return res.json({
+                success: true,
+                message: 'Package configuration updated successfully',
+                package: transformedPackage,
+                preservedFields: true,
+            });
+        }
+        catch (error) {
+            console.error('Error updating package configuration:', error);
+            // Ensure we always return JSON, even for errors
+            return res.status(500).json({
+                success: false,
+                error: 'Failed to update package configuration',
+                message: error instanceof Error ? error.message : 'Unknown error occurred',
+            });
+        }
+    });
+    // Error handling middleware
+    app.use((error, _req, res, _next) => {
+        console.error('Error:', error);
+        res.status(500).json({
+            error: 'Internal server error',
+            message: error.message,
+            timestamp: Date.now(),
+        });
+    });
+    // 404 handler
+    app.use('*', (_, res) => {
+        res.status(404).json({
+            error: 'Endpoint not found',
+            timestamp: Date.now(),
+        });
+    });
+    const PORT = parseInt(port ? port.toString() : '4000');
+    app
+        .listen(PORT, host, async () => {
+        const pcount = await prisma.package.count();
+        console.log(`[Database] Total packages found: ${pcount}`);
+        console.log(`🚀 Backend server running on http://${host}:${PORT}`);
+        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(`   - GET  /api/commits/:packagePath`);
+        // console.log(`   - GET  /api/graph`);
+        console.log(`   - GET  /api/stats`);
+        console.log(`   - GET  /api/ci/status`);
+        console.log(`   - POST /api/ci/trigger`);
+        console.log(`   - POST /api/scan`);
+        console.log(`   - GET  /api/health/packages`);
+        console.log(`   - GET  /api/search`);
+        console.log(`   - GET  /api/activity`);
+        console.log(`   - GET  /api/system`);
+    })
+        .on('error', err => {
+        // Handle common errors like EADDRINUSE (port already in use)
+        if (err.message.includes('EADDRINUSE')) {
+            console.error(`Error: Port ${port} is already in use. Please specify a different port via configuration file.`);
+            process.exit(1);
+        }
+        else {
+            console.error('Server failed to start:', err);
+            process.exit(1);
+        }
+    });
+    // const appD = express();
+    // // Serve static files from the 'dist' directory
+    // appD.use(express.static(rootPath + '/apps/dashboard/dist'));
+    // // For any other routes, serve the index.html
+    // appD.get('*', (req, res) => {
+    //   res.sendFile(path.join(rootPath, '/apps/dashboard/dist', 'index.html'));
+    // });
+    // appD.listen(3000, () => {
+    //   console.log(`dashboard Server listening at http://localhost:${3000}`);
+    // });
+    // export default app;
+    // const overallScore =
+    //   healthMetrics.reduce((sum, h) => sum + h.health!.overallScore, 0) /
+    //   healthMetrics.length;
+    // const metrics: HealthMetric[] = [
+    //   {
+    //     name: 'Package Health',
+    //     value: healthMetrics.filter(h => h.isHealthy).length || 0,
+    //     status: calculateHealthStatus(
+    //       healthMetrics.filter(h => h.isHealthy).length,
+    //       packages.length
+    //     ),
+    //     description: `${healthMetrics.filter(h => h.isHealthy).length || 0} healthy packages out of ${packages.length || 0}`,
+    //   },
+    //   {
+    //     name: 'Overall Score',
+    //     value: Math.round(overallScore),
+    //     status:
+    //       Math.round(overallScore) >= 80
+    //         ? 'healthy'
+    //         : Math.round(overallScore) >= 60
+    //           ? 'warning'
+    //           : 'error',
+    //     description: `Average health score: ${Math.round(overallScore)}/100`,
+    //   },
+    //   {
+    //     name: 'Unhealthy Packages',
+    //     value: healthMetrics.filter(h => !h.isHealthy).length || 0,
+    //     status:
+    //       (healthMetrics.filter(h => !h.isHealthy).length || 0) === 0
+    //         ? 'healthy'
+    //         : (healthMetrics.filter(h => !h.isHealthy).length || 0) <= 2
+    //           ? 'warning'
+    //           : 'error',
+    //     description: `${healthMetrics.filter(h => !h.isHealthy).length || 0} packages need attention`,
+    //   },
+    // ];
+    // const packageHealth = packages.map((pkg: any) => ({
+    //   package: pkg.packageName,
+    //   score: pkg.health?.overallScore || 0,
+    //   issues: pkg.error
+    //     ? [pkg.error]
+    //     : (pkg.health?.overallScore || 0) < 80
+    //       ? ['Needs improvement']
+    //       : [],
+    // }));
+    // res.status(200).json({
+    //   overallScore,
+    //   metrics,
+    //   packageHealth,
+    // });
+}
+function serveDashboard(rootPath, port, host) {
+    const app = (0, express_1.default)();
+    app.get('/env-config.js', (req, res) => {
+        res.setHeader('Content-Type', 'application/javascript');
+        res.send(`window.ENV = { API_URL: "${`${config_loader_1.appConfig.server.host}:${config_loader_1.appConfig.server.port}` || 'localhost:8999'}" };`);
+    });
+    // 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)$/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_1.default.resolve(__dirname, '..', 'monodog-dashboard', 'dist'),
+            });
+        }
+    });
+    const staticPath = path_1.default.join(__dirname, '..', 'monodog-dashboard', 'dist');
+    console.log('Serving static files from:', staticPath);
+    app.use(express_1.default.static(staticPath));
+    // Start the server
+    const PORT = parseInt(port ? port.toString() : '8999');
+    app.listen(PORT, host, () => {
+        console.log(`App listening on ${host}:${port}`);
+        console.log('Press Ctrl+C to quit.');
+    });
+}