@woopsy/mcpanel 1.0.0

package/dist/managers/serverManager.js

@@ -0,0 +1,243 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const helpers_1 = require("../utils/helpers");
+const logger_1 = require("../utils/logger");
+class ServerManager {
+    configManager;
+    constructor(configManager) {
+        this.configManager = configManager;
+    }
+    /**
+     * Helper to ensure server name is safe for directories (alphanumeric, dashes, underscores)
+     */
+    cleanServerName(name) {
+        return name.replace(/[^a-zA-Z0-9_\-]/g, '');
+    }
+    /**
+     * Inspects a server folder and best-effort detects the server software
+     * (Paper, Fabric, Purpur, Vanilla, ...) and the Minecraft version.
+     */
+    detectServerInfo(dir) {
+        let software = 'Vanilla';
+        let version = 'Unknown';
+        let files = [];
+        try {
+            files = fs.readdirSync(dir);
+        }
+        catch {
+            return { software, version };
+        }
+        const lowerFiles = files.map(f => f.toLowerCase());
+        const jars = lowerFiles.filter(f => f.endsWith('.jar'));
+        const jarBlob = jars.join(' ');
+        // --- Software detection ---
+        const hasFabric = lowerFiles.includes('fabric-server-launch.jar') ||
+            lowerFiles.includes('fabric-server-launcher.properties') ||
+            lowerFiles.includes('.fabric') ||
+            lowerFiles.some(f => f.startsWith('fabric-server')) ||
+            jarBlob.includes('fabric');
+        if (hasFabric)
+            software = 'Fabric';
+        else if (jarBlob.includes('purpur'))
+            software = 'Purpur';
+        else if (jarBlob.includes('paper'))
+            software = 'Paper';
+        else if (jarBlob.includes('spigot'))
+            software = 'Spigot';
+        else if (jarBlob.includes('forge') || lowerFiles.some(f => f.includes('forge')))
+            software = 'Forge';
+        else if (jarBlob.includes('velocity'))
+            software = 'Velocity';
+        else if (jarBlob.includes('waterfall'))
+            software = 'Waterfall';
+        else if (jarBlob.includes('bukkit'))
+            software = 'CraftBukkit';
+        // --- Version detection ---
+        // 1) Paper/Purpur write a version_history.json with the real MC version.
+        const vhPath = path.join(dir, 'version_history.json');
+        if (fs.existsSync(vhPath)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(vhPath, 'utf-8'));
+                const cur = data.currentVersion || '';
+                const m = cur.match(/MC:\s*([\d.]+)/) || cur.match(/(\d+\.\d+(?:\.\d+)?)/);
+                if (m)
+                    version = m[1];
+            }
+            catch { /* ignore */ }
+        }
+        // 2) Fabric/modern servers store the MC version as a `versions/<ver>` folder.
+        if (version === 'Unknown') {
+            const versionsDir = path.join(dir, 'versions');
+            try {
+                const subdirs = fs.readdirSync(versionsDir, { withFileTypes: true })
+                    .filter(d => d.isDirectory() && /\d+\.\d+/.test(d.name))
+                    .map(d => d.name);
+                if (subdirs.length > 0)
+                    version = subdirs[0];
+            }
+            catch { /* no versions dir */ }
+        }
+        // 3) Fall back to a version number embedded in a jar filename.
+        if (version === 'Unknown') {
+            const m = jarBlob.match(/(\d+\.\d+(?:\.\d+)?)/);
+            if (m)
+                version = m[1];
+        }
+        return { software, version };
+    }
+    /**
+     * Validates and connects an existing Minecraft server directory as THE
+     * single server this CLI manages. Persists it to config.
+     */
+    syncServer(dirPath) {
+        // Translate Windows paths (e.g. C:\...) into WSL mount paths when needed.
+        const raw = (0, helpers_1.normalizeInputPath)(dirPath);
+        const resolvedPath = path.resolve(raw);
+        if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isDirectory()) {
+            throw new Error(`Folder "${resolvedPath}" does not exist.`);
+        }
+        // Verify it looks like a Minecraft server directory.
+        const files = fs.readdirSync(resolvedPath);
+        const hasProperties = files.includes('server.properties');
+        const hasJar = files.some(f => f.toLowerCase().endsWith('.jar'));
+        if (!hasProperties && !hasJar) {
+            throw new Error('Not a valid Minecraft server folder — no server.properties or .jar file was found.');
+        }
+        const { software, version } = this.detectServerInfo(resolvedPath);
+        const name = this.cleanServerName(path.basename(resolvedPath)) || 'server';
+        // Ensure the EULA is accepted so the server won't refuse to launch.
+        const eulaPath = path.join(resolvedPath, 'eula.txt');
+        if (!fs.existsSync(eulaPath)) {
+            try {
+                fs.writeFileSync(eulaPath, 'eula=true\n', 'utf-8');
+            }
+            catch { /* ignore */ }
+        }
+        // Preserve a previously chosen RAM allocation if re-syncing the same folder.
+        const existing = this.configManager.getServer();
+        const ram = existing && path.resolve(existing.path) === resolvedPath
+            ? existing.ram
+            : this.configManager.getConfig().defaultRam;
+        const meta = {
+            name,
+            path: resolvedPath,
+            version,
+            software,
+            ram,
+        };
+        this.configManager.setServer(meta);
+        logger_1.logger.info(`Synced Minecraft server "${name}" at ${resolvedPath} (${software} ${version})`);
+        return meta;
+    }
+    /**
+     * Helper to parse server.properties file.
+     */
+    readPropertiesFile(filePath) {
+        if (!fs.existsSync(filePath)) {
+            return {};
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split(/\r?\n/);
+        const properties = {};
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('#') || !trimmed.includes('=')) {
+                continue;
+            }
+            const eqIdx = trimmed.indexOf('=');
+            const key = trimmed.substring(0, eqIdx).trim();
+            const value = trimmed.substring(eqIdx + 1).trim();
+            properties[key] = value;
+        }
+        return properties;
+    }
+    /**
+     * Helper to write server.properties file.
+     */
+    writePropertiesFile(filePath, properties) {
+        let content = '';
+        // If file exists, we want to preserve comments and update keys
+        if (fs.existsSync(filePath)) {
+            const fileLines = fs.readFileSync(filePath, 'utf-8').split(/\r?\n/);
+            const writtenKeys = new Set();
+            for (const line of fileLines) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith('#') || !trimmed.includes('=')) {
+                    content += line + '\n';
+                    continue;
+                }
+                const eqIdx = trimmed.indexOf('=');
+                const key = trimmed.substring(0, eqIdx).trim();
+                if (properties[key] !== undefined) {
+                    content += `${key}=${properties[key]}\n`;
+                    writtenKeys.add(key);
+                }
+                else {
+                    content += line + '\n';
+                }
+            }
+            // Append any new properties that were not in the file originally
+            for (const [key, value] of Object.entries(properties)) {
+                if (!writtenKeys.has(key)) {
+                    content += `${key}=${value}\n`;
+                }
+            }
+        }
+        else {
+            // Just write new properties
+            content += '#Minecraft server properties\n';
+            for (const [key, value] of Object.entries(properties)) {
+                content += `${key}=${value}\n`;
+            }
+        }
+        fs.writeFileSync(filePath, content, 'utf-8');
+    }
+    /**
+     * Updates server.properties of the managed server.
+     */
+    updateServerProperties(updates) {
+        const server = this.configManager.getServer();
+        if (!server) {
+            throw new Error('No server is connected.');
+        }
+        const propertiesPath = path.join(server.path, 'server.properties');
+        this.writePropertiesFile(propertiesPath, updates);
+    }
+}
+exports.ServerManager = ServerManager;

package/dist/services/downloadService.js

@@ -0,0 +1,176 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadService = void 0;
+exports.downloadFile = downloadFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const configManager_1 = require("../config/configManager");
+const logger_1 = require("../utils/logger");
+const DOWNLOADS_DIR = path.join(configManager_1.APP_ROOT, 'downloads');
+/**
+ * Downloads a file from a URL with redirection support and reports progress.
+ */
+function downloadFile(url, destPath, onProgress) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': 'mcpanel-agent' } }, (res) => {
+            // Handle redirects
+            if ([301, 302, 307, 308].includes(res.statusCode || 0)) {
+                if (res.headers.location) {
+                    downloadFile(res.headers.location, destPath, onProgress).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`Server returned HTTP ${res.statusCode}: ${res.statusMessage}`));
+                return;
+            }
+            const totalBytes = Number(res.headers['content-length'] || 0);
+            const fileStream = fs.createWriteStream(destPath);
+            let downloadedBytes = 0;
+            res.on('data', (chunk) => {
+                downloadedBytes += chunk.length;
+                fileStream.write(chunk);
+                if (onProgress) {
+                    onProgress(downloadedBytes, totalBytes);
+                }
+            });
+            res.on('end', () => {
+                fileStream.end();
+                resolve();
+            });
+            res.on('error', (err) => {
+                fileStream.close();
+                fs.unlink(destPath, () => { });
+                reject(err);
+            });
+        }).on('error', (err) => {
+            fs.unlink(destPath, () => { });
+            reject(err);
+        });
+    });
+}
+/**
+ * Fetches JSON response from a URL (used for API queries)
+ */
+function fetchJSON(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': 'mcpanel-agent' } }, (res) => {
+            if ([301, 302, 307, 308].includes(res.statusCode || 0)) {
+                if (res.headers.location) {
+                    fetchJSON(res.headers.location).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`Failed to fetch JSON: HTTP ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', chunk => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }).on('error', reject);
+    });
+}
+class DownloadService {
+    /**
+     * Resolves the download URL for the specified Minecraft software and version.
+     */
+    async getDownloadUrl(software, version) {
+        const sw = software.toLowerCase();
+        if (sw === 'paper' || sw === 'velocity' || sw === 'waterfall') {
+            const project = sw;
+            const versionUrl = `https://api.papermc.io/v2/projects/${project}/versions/${version}`;
+            try {
+                const versionData = await fetchJSON(versionUrl);
+                const builds = versionData.builds;
+                if (!builds || builds.length === 0) {
+                    throw new Error(`No builds found for version ${version}`);
+                }
+                const latestBuild = builds[builds.length - 1];
+                const buildUrl = `https://api.papermc.io/v2/projects/${project}/versions/${version}/builds/${latestBuild}`;
+                const buildData = await fetchJSON(buildUrl);
+                const downloadFile = buildData.downloads.application.name;
+                return `https://api.papermc.io/v2/projects/${project}/versions/${version}/builds/${latestBuild}/downloads/${downloadFile}`;
+            }
+            catch (err) {
+                logger_1.logger.error(`Error resolving PaperMC API download URL for ${software} ${version}`, err);
+                throw new Error(`Failed to resolve PaperMC download link: ${err.message}`);
+            }
+        }
+        else if (sw === 'purpur') {
+            // Purpur supports a simple redirecting link for the latest build of a version
+            return `https://api.purpurmc.org/v2/purpur/${version}/latest/download`;
+        }
+        throw new Error(`Unsupported software type: ${software}`);
+    }
+    /**
+     * Downloads the server jar file if not already cached.
+     * Returns the absolute path to the downloaded jar file.
+     */
+    async downloadServerJar(software, version, onProgress) {
+        const sw = software.toLowerCase();
+        const jarName = `${sw}-${version}.jar`;
+        const cachedPath = path.join(DOWNLOADS_DIR, jarName);
+        if (fs.existsSync(cachedPath)) {
+            logger_1.logger.info(`Using cached server jar: ${cachedPath}`);
+            if (onProgress)
+                onProgress(100);
+            return cachedPath;
+        }
+        logger_1.logger.info(`Fetching download URL for ${software} version ${version}...`);
+        const downloadUrl = await this.getDownloadUrl(software, version);
+        logger_1.logger.info(`Downloading server jar from: ${downloadUrl}`);
+        const tempPath = `${cachedPath}.tmp`;
+        await downloadFile(downloadUrl, tempPath, (downloaded, total) => {
+            if (onProgress && total > 0) {
+                const pct = parseFloat(((downloaded / total) * 100).toFixed(1));
+                onProgress(pct);
+            }
+        });
+        fs.renameSync(tempPath, cachedPath);
+        logger_1.logger.info(`Server jar downloaded and saved to: ${cachedPath}`);
+        return cachedPath;
+    }
+}
+exports.DownloadService = DownloadService;

package/dist/services/processManager.js

@@ -0,0 +1,242 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessManager = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const logger_1 = require("../utils/logger");
+const helpers_1 = require("../utils/helpers");
+class ProcessManager {
+    activeServers = new Map();
+    consoleCallbacks = new Map();
+    /**
+     * Starts a server process.
+     */
+    startServer(name, serverDir, jarPath, ram, javaPath = 'java') {
+        return new Promise((resolve, reject) => {
+            const key = name.toLowerCase();
+            if (this.activeServers.has(key)) {
+                reject(new Error(`Server "${name}" is already running.`));
+                return;
+            }
+            // Check if Java is installed
+            const javaCheck = (0, helpers_1.checkJava)(javaPath);
+            if (!javaCheck.installed) {
+                reject(new Error(`Java was not found at "${javaPath}". Please ensure Java is installed.`));
+                return;
+            }
+            if (!fs.existsSync(jarPath)) {
+                reject(new Error(`Server jar was not found at "${jarPath}".`));
+                return;
+            }
+            logger_1.logger.logServerStart(name, `Launching Java process in ${serverDir} with ${ram} RAM`);
+            // Prepare JVM arguments. Ensure RAM syntax (e.g. 4G -> -Xmx4G)
+            const cleanedRam = ram.replace(/[^0-9a-zA-Z]/g, '');
+            const args = [
+                `-Xmx${cleanedRam}`,
+                `-Xms${cleanedRam}`,
+                '-jar',
+                jarPath,
+                'nogui'
+            ];
+            // Spawn process inside the server directory
+            const child = (0, child_process_1.spawn)(javaPath, args, {
+                cwd: serverDir,
+                shell: false,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            const serverInfo = {
+                name,
+                process: child,
+                status: 'Starting',
+                startTime: Date.now(),
+                pid: child.pid || 0,
+            };
+            this.activeServers.set(key, serverInfo);
+            // Clean/reset console log on start
+            const logFilePath = logger_1.logger.getServerLogPath(name);
+            try {
+                if (fs.existsSync(logFilePath)) {
+                    fs.writeFileSync(logFilePath, '', 'utf-8');
+                }
+            }
+            catch (err) {
+                logger_1.logger.error(`Failed to clear console log for ${name}`, err);
+            }
+            // Handle stdout
+            child.stdout.on('data', (data) => {
+                const chunk = data.toString();
+                logger_1.logger.writeServerConsoleLog(name, chunk);
+                // Check for startup completion keywords
+                if (serverInfo.status === 'Starting') {
+                    if (chunk.includes('Done (') ||
+                        chunk.includes('For help, type "help"') ||
+                        chunk.includes('Starting velocity server') || // velocity starts quickly
+                        chunk.includes('Ready for connections')) {
+                        serverInfo.status = 'Running';
+                        logger_1.logger.logServerStart(name, `Server fully loaded (PID: ${child.pid})`);
+                    }
+                }
+                // Forward to console streaming callbacks
+                const callback = this.consoleCallbacks.get(key);
+                if (callback) {
+                    callback(chunk);
+                }
+            });
+            // Handle stderr
+            child.stderr.on('data', (data) => {
+                const chunk = data.toString();
+                logger_1.logger.writeServerConsoleLog(name, `[STDERR] ${chunk}`);
+                const callback = this.consoleCallbacks.get(key);
+                if (callback) {
+                    callback(`[STDERR] ${chunk}`);
+                }
+            });
+            // Handle process exit
+            child.on('close', (code) => {
+                logger_1.logger.logServerStop(name, `Process exited with code ${code}`);
+                this.activeServers.delete(key);
+                this.consoleCallbacks.delete(key);
+            });
+            child.on('error', (err) => {
+                logger_1.logger.error(`Process error for server "${name}"`, err);
+                reject(err);
+            });
+            // Wait a moment to ensure it spawns without immediate crash
+            setTimeout(() => {
+                if (child.pid) {
+                    resolve();
+                }
+                else {
+                    reject(new Error('Process failed to spawn'));
+                }
+            }, 500);
+        });
+    }
+    /**
+     * Stops a server process gracefully, falling back to SIGKILL.
+     */
+    async stopServer(name) {
+        const key = name.toLowerCase();
+        const server = this.activeServers.get(key);
+        if (!server) {
+            return false;
+        }
+        logger_1.logger.logServerStop(name, 'Graceful shutdown initiated.');
+        server.status = 'Offline'; // Update state immediately
+        return new Promise((resolve) => {
+            // Send "stop" command to standard input
+            try {
+                if (server.process.stdin) {
+                    server.process.stdin.write('stop\n');
+                }
+                else {
+                    logger_1.logger.error(`Cannot stop server ${name}: stdin is not available.`);
+                }
+            }
+            catch (err) {
+                logger_1.logger.error(`Failed to write stop command to stdin of ${name}`, err);
+            }
+            // Check if process has exited within 15 seconds, otherwise kill it
+            const timeout = setTimeout(() => {
+                if (this.activeServers.has(key)) {
+                    logger_1.logger.warn(`Server ${name} did not stop gracefully. Force killing process (PID: ${server.pid})`);
+                    try {
+                        server.process.kill('SIGKILL');
+                    }
+                    catch (err) {
+                        logger_1.logger.error(`Error killing server ${name} process`, err);
+                    }
+                }
+                resolve(true);
+            }, 15000);
+            // Listen for process exit to resolve immediately
+            server.process.on('exit', () => {
+                clearTimeout(timeout);
+                this.activeServers.delete(key);
+                resolve(true);
+            });
+        });
+    }
+    /**
+     * Sends terminal command input to a running server console.
+     */
+    sendCommand(name, command) {
+        const key = name.toLowerCase();
+        const server = this.activeServers.get(key);
+        if (!server) {
+            return false;
+        }
+        try {
+            if (server.process.stdin) {
+                server.process.stdin.write(command + '\n');
+                return true;
+            }
+            else {
+                logger_1.logger.error(`Failed to send command to ${name}: stdin is null.`);
+                return false;
+            }
+        }
+        catch (err) {
+            logger_1.logger.error(`Failed to send command to ${name}: ${command}`, err);
+            return false;
+        }
+    }
+    /**
+     * Registers a console logging callback for active log streaming.
+     */
+    registerConsoleStream(name, callback) {
+        this.consoleCallbacks.set(name.toLowerCase(), callback);
+    }
+    /**
+     * Unregisters console logging callback.
+     */
+    unregisterConsoleStream(name) {
+        this.consoleCallbacks.delete(name.toLowerCase());
+    }
+    /**
+     * Returns list of running server PIDs and states.
+     */
+    getActiveServers() {
+        return this.activeServers;
+    }
+    /**
+     * Gets details for a specific active server.
+     */
+    getActiveServer(name) {
+        return this.activeServers.get(name.toLowerCase());
+    }
+}
+exports.ProcessManager = ProcessManager;