@bigtyphoon/melo 1.7.6 → 1.8.1

package/bin/commands/doctor.ts

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+
+/**
+ * Check and validate project configuration
+ * Reports errors and warnings for common configuration issues
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+
+interface CheckResult {
+    type: 'error' | 'warning' | 'info' | 'success';
+    message: string;
+    file?: string;
+    fix?: string;
+}
+
+export default function (program: Command) {
+    program.command('doctor')
+        .description('Check project configuration for errors and warnings')
+        .option('-f, --fix', 'attempt to fix minor issues automatically', false)
+        .action(function (opts: { fix: boolean }) {
+            runDoctor(opts.fix);
+        });
+}
+
+function runDoctor(autoFix: boolean) {
+    const cwd = process.cwd();
+    const results: CheckResult[] = [];
+
+    console.info('🔍 Checking melo project configuration...\n');
+
+    // Check 1: Is this a valid melo project?
+    if (!isMeloProject(cwd)) {
+        results.push({
+            type: 'error',
+            message: 'Not a valid melo project.',
+            fix: 'Run "melo init" to create a new project.'
+        });
+        printResults(results);
+        process.exit(1);
+    }
+
+    results.push({
+        type: 'success',
+        message: 'Valid melo project structure found.'
+    });
+
+    // Check 2: Validate adminServer.json
+    results.push(...checkAdminServerJson(cwd));
+
+    // Check 3: Validate servers.json
+    results.push(...checkServersJson(cwd));
+
+    // Check 4: Validate app.ts
+    results.push(...checkAppTs(cwd));
+
+    // Check 5: Check server directories consistency
+    results.push(...checkServerDirectories(cwd));
+
+    // Check 6: Check for duplicate server IDs
+    results.push(...checkDuplicateServerIds(cwd));
+
+    // Check 7: Check port conflicts
+    results.push(...checkPortConflicts(cwd));
+
+    // Check 8: Check for missing handler/remote files
+    results.push(...checkMissingHandlers(cwd));
+
+    printResults(results);
+
+    const errors = results.filter(r => r.type === 'error').length;
+    const warnings = results.filter(r => r.type === 'warning').length;
+    const fixes = results.filter(r => r.fix).length;
+
+    console.info(`\n📊 Summary: ${errors} errors, ${warnings} warnings`);
+    
+    if (errors === 0 && warnings === 0) {
+        console.info('✅ All checks passed! Your project looks good.');
+    } else if (errors === 0) {
+        console.info('⚠️  Project has some warnings but should work.');
+    } else {
+        console.info('❌ Please fix the errors above before starting the server.');
+    }
+
+    if (fixes > 0 && !autoFix) {
+        console.info(`\n💡 Run "melo doctor --fix" to attempt automatic fixes for some issues.`);
+    }
+
+    process.exit(errors > 0 ? 1 : 0);
+}
+
+function isMeloProject(cwd: string): boolean {
+    const requiredPaths = ['app.ts', 'config', 'app/servers'];
+    return requiredPaths.every(p => fs.existsSync(path.join(cwd, p)));
+}
+
+function checkAdminServerJson(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const filePath = path.join(cwd, 'config', 'adminServer.json');
+
+    if (!fs.existsSync(filePath)) {
+        results.push({
+            type: 'error',
+            message: 'adminServer.json not found.',
+            file: 'config/adminServer.json',
+            fix: 'Create adminServer.json with at least master server configuration.'
+        });
+        return results;
+    }
+
+    let adminServers: any[];
+    try {
+        adminServers = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (e) {
+        results.push({
+            type: 'error',
+            message: 'adminServer.json is not valid JSON.',
+            file: 'config/adminServer.json',
+            fix: 'Fix JSON syntax errors.'
+        });
+        return results;
+    }
+
+    if (!Array.isArray(adminServers)) {
+        results.push({
+            type: 'error',
+            message: 'adminServer.json must be an array.',
+            file: 'config/adminServer.json'
+        });
+        return results;
+    }
+
+    // Check for master
+    const hasMaster = adminServers.some(s => s.type === 'master');
+    if (!hasMaster) {
+        results.push({
+            type: 'error',
+            message: 'Missing "master" server type in adminServer.json.',
+            file: 'config/adminServer.json',
+            fix: 'Add master server configuration.'
+        });
+    }
+
+    // Check for connector
+    const hasConnector = adminServers.some(s => s.type === 'connector');
+    if (!hasConnector) {
+        results.push({
+            type: 'warning',
+            message: 'Missing "connector" server type. Project may not accept client connections.',
+            file: 'config/adminServer.json'
+        });
+    }
+
+    // Check for duplicate types
+    const types = adminServers.map(s => s.type);
+    const duplicates = types.filter((item, index) => types.indexOf(item) !== index);
+    if (duplicates.length > 0) {
+        results.push({
+            type: 'error',
+            message: `Duplicate server types found: ${[...new Set(duplicates)].join(', ')}`,
+            file: 'config/adminServer.json'
+        });
+    }
+
+    // Check for missing tokens
+    adminServers.forEach(server => {
+        if (!server.token) {
+            results.push({
+                type: 'warning',
+                message: `Server type "${server.type}" is missing a token.`,
+                file: 'config/adminServer.json',
+                fix: 'Add a secure token for this server type.'
+            });
+        }
+    });
+
+    return results;
+}
+
+function checkServersJson(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const filePath = path.join(cwd, 'config', 'servers.json');
+
+    if (!fs.existsSync(filePath)) {
+        results.push({
+            type: 'error',
+            message: 'servers.json not found.',
+            file: 'config/servers.json'
+        });
+        return results;
+    }
+
+    let servers: any;
+    try {
+        servers = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (e) {
+        results.push({
+            type: 'error',
+            message: 'servers.json is not valid JSON.',
+            file: 'config/servers.json'
+        });
+        return results;
+    }
+
+    // Check environments
+    ['development', 'production'].forEach(env => {
+        if (!servers[env]) {
+            results.push({
+                type: 'warning',
+                message: `Missing "${env}" environment configuration.`,
+                file: 'config/servers.json'
+            });
+        }
+    });
+
+    // Check each environment
+    Object.keys(servers).forEach(env => {
+        const envConfig = servers[env];
+        
+        // Check for master
+        if (!envConfig.master || envConfig.master.length === 0) {
+            results.push({
+                type: 'error',
+                message: `Missing master server in "${env}" environment.`,
+                file: 'config/servers.json'
+            });
+        }
+
+        // Validate server entries
+        Object.keys(envConfig).forEach(serverType => {
+            const serverList = envConfig[serverType];
+            
+            if (!Array.isArray(serverList)) {
+                results.push({
+                    type: 'error',
+                    message: `Server type "${serverType}" in "${env}" must be an array.`,
+                    file: 'config/servers.json'
+                });
+                return;
+            }
+
+            serverList.forEach((server: any, index: number) => {
+                if (!server.id) {
+                    results.push({
+                        type: 'error',
+                        message: `Server #${index + 1} of type "${serverType}" in "${env}" is missing an ID.`,
+                        file: 'config/servers.json'
+                    });
+                }
+
+                if (!server.host) {
+                    results.push({
+                        type: 'warning',
+                        message: `Server "${server.id || index}" in "${env}" is missing host.`,
+                        file: 'config/servers.json'
+                    });
+                }
+
+                if (!server.port && server.port !== 0) {
+                    results.push({
+                        type: 'error',
+                        message: `Server "${server.id || index}" in "${env}" is missing port.`,
+                        file: 'config/servers.json'
+                    });
+                }
+
+                // Check frontend servers have clientPort
+                if (server.frontend && !server.clientPort && server.clientPort !== 0) {
+                    results.push({
+                        type: 'warning',
+                        message: `Frontend server "${server.id}" in "${env}" is missing clientPort.`,
+                        file: 'config/servers.json'
+                    });
+                }
+            });
+        });
+    });
+
+    return results;
+}
+
+function checkAppTs(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const filePath = path.join(cwd, 'app.ts');
+
+    if (!fs.existsSync(filePath)) {
+        return results;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+
+    // Check for app.start()
+    if (!content.includes('app.start()')) {
+        results.push({
+            type: 'error',
+            message: 'app.ts is missing app.start() call.',
+            file: 'app.ts'
+        });
+    }
+
+    // Check for melo import
+    if (!content.includes('@bigtyphoon/melo') && !content.includes('melo')) {
+        results.push({
+            type: 'error',
+            message: 'app.ts is missing melo import.',
+            file: 'app.ts'
+        });
+    }
+
+    // Check for app.createApp()
+    if (!content.includes('createApp')) {
+        results.push({
+            type: 'error',
+            message: 'app.ts should call melo.createApp().',
+            file: 'app.ts'
+        });
+    }
+
+    return results;
+}
+
+function checkServerDirectories(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const serversDir = path.join(cwd, 'app', 'servers');
+    
+    if (!fs.existsSync(serversDir)) {
+        return results;
+    }
+
+    const serverTypes = fs.readdirSync(serversDir).filter(f => {
+        return fs.statSync(path.join(serversDir, f)).isDirectory();
+    });
+
+    // Check if each server type has handler or remote directory
+    serverTypes.forEach(serverType => {
+        const serverPath = path.join(serversDir, serverType);
+        const hasHandler = fs.existsSync(path.join(serverPath, 'handler'));
+        const hasRemote = fs.existsSync(path.join(serverPath, 'remote'));
+
+        if (!hasHandler && !hasRemote) {
+            results.push({
+                type: 'warning',
+                message: `Server type "${serverType}" has neither handler nor remote directory.`,
+                file: `app/servers/${serverType}`
+            });
+        }
+
+        // Check handler directory is not empty
+        if (hasHandler) {
+            const handlerFiles = fs.readdirSync(path.join(serverPath, 'handler'))
+                .filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+            if (handlerFiles.length === 0) {
+                results.push({
+                    type: 'warning',
+                    message: `Handler directory for "${serverType}" is empty.`,
+                    file: `app/servers/${serverType}/handler`
+                });
+            }
+        }
+    });
+
+    return results;
+}
+
+function checkDuplicateServerIds(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const filePath = path.join(cwd, 'config', 'servers.json');
+
+    if (!fs.existsSync(filePath)) {
+        return results;
+    }
+
+    let servers: any;
+    try {
+        servers = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (e) {
+        return results;
+    }
+
+    Object.keys(servers).forEach(env => {
+        const envConfig = servers[env];
+        const ids: string[] = [];
+        
+        Object.keys(envConfig).forEach(serverType => {
+            const serverList = envConfig[serverType];
+            if (Array.isArray(serverList)) {
+                serverList.forEach((server: any) => {
+                    if (server.id) {
+                        if (ids.includes(server.id)) {
+                            results.push({
+                                type: 'error',
+                                message: `Duplicate server ID "${server.id}" in "${env}" environment.`,
+                                file: 'config/servers.json'
+                            });
+                        }
+                        ids.push(server.id);
+                    }
+                });
+            }
+        });
+    });
+
+    return results;
+}
+
+function checkPortConflicts(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const filePath = path.join(cwd, 'config', 'servers.json');
+
+    if (!fs.existsSync(filePath)) {
+        return results;
+    }
+
+    let servers: any;
+    try {
+        servers = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (e) {
+        return results;
+    }
+
+    Object.keys(servers).forEach(env => {
+        const envConfig = servers[env];
+        const ports: { port: number; server: string }[] = [];
+        
+        Object.keys(envConfig).forEach(serverType => {
+            const serverList = envConfig[serverType];
+            if (Array.isArray(serverList)) {
+                serverList.forEach((server: any) => {
+                    if (server.port) {
+                        const existing = ports.find(p => p.port === server.port);
+                        if (existing) {
+                            results.push({
+                                type: 'error',
+                                message: `Port conflict: "${server.id}" and "${existing.server}" both use port ${server.port} in "${env}".`,
+                                file: 'config/servers.json'
+                            });
+                        }
+                        ports.push({ port: server.port, server: server.id });
+                    }
+
+                    if (server.clientPort) {
+                        const existingClient = ports.find(p => p.port === server.clientPort);
+                        if (existingClient) {
+                            results.push({
+                                type: 'error',
+                                message: `Client port conflict: "${server.id}" and "${existingClient.server}" both use clientPort ${server.clientPort} in "${env}".`,
+                                file: 'config/servers.json'
+                            });
+                        }
+                        ports.push({ port: server.clientPort, server: server.id });
+                    }
+                });
+            }
+        });
+    });
+
+    return results;
+}
+
+function checkMissingHandlers(cwd: string): CheckResult[] {
+    const results: CheckResult[] = [];
+    const adminServerPath = path.join(cwd, 'config', 'adminServer.json');
+    
+    if (!fs.existsSync(adminServerPath)) {
+        return results;
+    }
+
+    let adminServers: any[];
+    try {
+        adminServers = JSON.parse(fs.readFileSync(adminServerPath, 'utf8'));
+    } catch (e) {
+        return results;
+    }
+
+    const serversDir = path.join(cwd, 'app', 'servers');
+    
+    adminServers.forEach(server => {
+        if (server.type === 'master') return; // master doesn't need handler
+
+        const serverPath = path.join(serversDir, server.type);
+        if (!fs.existsSync(serverPath)) {
+            results.push({
+                type: 'warning',
+                message: `Server type "${server.type}" is defined in adminServer.json but has no directory.`,
+                file: `app/servers/${server.type}`,
+                fix: `Run "melo add-server ${server.type}" to create the server directory.`
+            });
+        }
+    });
+
+    return results;
+}
+
+function printResults(results: CheckResult[]) {
+    const icons = {
+        error: '❌',
+        warning: '⚠️ ',
+        info: 'ℹ️ ',
+        success: '✅'
+    };
+
+    results.forEach(result => {
+        console.info(`${icons[result.type]} ${result.message}`);
+        if (result.file) {
+            console.info(`   📁 ${result.file}`);
+        }
+        if (result.fix) {
+            console.info(`   💡 ${result.fix}`);
+        }
+        console.info('');
+    });
+}

package/bin/utils/constants.ts

@@ -25,3 +25,7 @@ export let SCRIPT_NOT_FOUND = ('Fail to find an appropriate script to run,\nplea
 export let MASTER_HA_NOT_FOUND = ('Fail to find an appropriate masterha config file, \nplease check the current work directory or the arguments passed to.\n' as any).red;
 export let COMMAND_ERROR = ('Illegal command format. Use `melo --help` to get more info.\n' as any).red;
 export let DAEMON_INFO = 'The application is running in the background now.\n';
+
+// Add server type command
+export let ADD_SERVER_TYPE_INFO = 'Successfully added server type "${serverName}".\n\nGenerated files:\n  - app/servers/${serverName}/handler/${serverName}Handler.ts\n  - app/servers/${serverName}/remote/${serverName}Remote.ts\n  - Updated config/adminServer.json\n  - Updated config/servers.json\n  - Updated app.ts\n\nYou can now add server instances to config/servers.json.';
+export let ADD_SERVER_TYPE_EXISTS = 'Server type already exists. Use --force to overwrite or choose a different name.';