☰

Aternos Universal Plugin Loader

Universal loader for plugins, mods, and custom scripts on Aternos

// ==UserScript==
// @name         Aternos Universal Plugin Loader
// @namespace    http://tampermonkey.net/
// @version      3.0
// @description  Universal loader for plugins, mods, and custom scripts on Aternos
// @author       You
// @match        https://aternos.org/*
// @match        https://*.aternos.org/*
// @grant        GM.xmlHttpRequest
// @grant        GM.addStyle
// @grant        GM.notification
// @grant        GM.info
// @grant        GM.setValue
// @grant        GM.getValue
// @connect      *
// @run-at       document-end
// @license      MIT
// ==/UserScript==

class UniversalPluginLoader {
    constructor() {
        this.pluginsLoaded = 0;
        this.totalPlugins = 0;
        this.isInitialized = false;
        this.pluginRegistry = new Map();
        
        this.config = {
            timeout: 30000,
            retryAttempts: 2,
            retryDelay: 1000,
            sequentialLoading: true,
            enablePluginManager: true,
            autoUpdateCheck: false
        };
        
        // Enhanced plugin configuration with types
        this.plugins = Object.freeze([
            // === PLUGIN TYPES EXAMPLES ===
            
            // 1. JAVASCRIPT PLUGINS (Most common)
            {
                name: "Custom Chat Enhancer",
                url: "https://example.com/plugins/chat-enhancer.js",
                type: "script",
                enabled: true,
                description: "Enhances chat functionality"
            },
            
            // 2. CSS/THEME PLUGINS
            {
                name: "Dark Theme",
                url: "https://example.com/themes/dark-theme.css",
                type: "style",
                enabled: true,
                description: "Dark theme for Aternos"
            },
            
            // 3. JSON CONFIGURATION PLUGINS
            {
                name: "Server Settings",
                url: "https://example.com/configs/server-settings.json",
                type: "config",
                enabled: true,
                description: "Custom server configurations"
            },
            
            // 4. HTML WIDGET PLUGINS
            {
                name: "Status Widget",
                url: "https://example.com/widgets/status-widget.html",
                type: "widget",
                enabled: true,
                description: "Server status widget"
            },
            
            // 5. EXTERNAL LIBRARIES
            {
                name: "Utility Library",
                url: "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js",
                type: "library",
                enabled: true,
                description: "Utility functions library"
            },
            
            // 6. CUSTOM ELEMENTS
            {
                name: "Quick Actions",
                url: "https://example.com/plugins/quick-actions.js",
                type: "custom-element",
                enabled: true,
                description: "Adds quick action buttons"
            }
            
            // Add your actual plugin URLs here
            // Example for Minecraft server plugins:
            // {
            //     name: "EssentialsX Helper",
            //     url: "https://raw.githubusercontent.com/your-repo/essentials-helper/main/plugin.js",
            //     type: "script",
            //     enabled: true
            // }
        ]);
        
        this.bindMethods();
    }

    bindMethods() {
        this.init = this.init.bind(this);
        this.handleError = this.handleError.bind(this);
        this.handlePromiseRejection = this.handlePromiseRejection.bind(this);
        this.showStatusNotification = this.showStatusNotification.bind(this);
        this.togglePlugin = this.togglePlugin.bind(this);
        this.openPluginManager = this.openPluginManager.bind(this);
    }

    async init() {
        if (this.isInitialized) {
            this.log('Loader already initialized', 'warn');
            return;
        }

        try {
            this.isInitialized = true;
            await this.waitForDOMReady();
            await this.waitForAternosInterface();
            await this.loadPlugins();
            await this.injectPluginManager();
            this.setupErrorHandling();
            this.log('Universal Plugin Loader initialized successfully', 'success');
        } catch (error) {
            this.handleError('Initialization failed', error);
        }
    }

    waitForDOMReady() {
        return new Promise((resolve) => {
            if (document.readyState === 'loading') {
                document.addEventListener('DOMContentLoaded', resolve, { once: true });
            } else {
                resolve();
            }
        });
    }

    waitForAternosInterface() {
        const aternosSelectors = [
            '.server-status',
            '.navigation',
            '[class*="aternos"]',
            '[id*="aternos"]',
            'body'
        ];

        return new Promise((resolve) => {
            const checkInterface = () => {
                const isLoaded = aternosSelectors.some(selector => {
                    try {
                        return document.querySelector(selector);
                    } catch (e) {
                        return false;
                    }
                });
                
                if (isLoaded) {
                    resolve();
                } else {
                    setTimeout(checkInterface, 500);
                }
            };
            
            checkInterface();
            setTimeout(resolve, 10000);
        });
    }

    async loadPlugins() {
        if (!this.plugins || !Array.isArray(this.plugins)) {
            this.log('Invalid plugins configuration', 'error');
            return;
        }

        const enabledPlugins = this.plugins.filter(plugin => 
            plugin && plugin.enabled !== false && plugin.url
        );

        this.totalPlugins = enabledPlugins.length;
        
        if (this.totalPlugins === 0) {
            this.log('No enabled plugins configured', 'info');
            return;
        }

        this.log(`Loading ${this.totalPlugins} plugins...`, 'info');

        try {
            if (this.config.sequentialLoading) {
                for (const [index, plugin] of enabledPlugins.entries()) {
                    await this.loadSinglePlugin(plugin, index);
                    await this.delay(100);
                }
            } else {
                const concurrencyLimit = 3;
                for (let i = 0; i < enabledPlugins.length; i += concurrencyLimit) {
                    const chunk = enabledPlugins.slice(i, i + concurrencyLimit);
                    await Promise.allSettled(
                        chunk.map((plugin, index) => 
                            this.loadSinglePlugin(plugin, i + index)
                        )
                    );
                }
            }

            this.log(`Completed loading ${this.pluginsLoaded}/${this.totalPlugins} plugins`, 'success');
        } catch (error) {
            this.handleError('Plugin loading process failed', error);
        }
    }

    async loadSinglePlugin(plugin, index) {
        try {
            this.log(`Loading plugin ${index + 1}/${this.totalPlugins}: ${plugin.name}`, 'info');
            
            switch (plugin.type) {
                case 'script':
                case 'library':
                case 'custom-element':
                    await this.loadScriptPlugin(plugin);
                    break;
                    
                case 'style':
                case 'theme':
                    await this.loadStylePlugin(plugin);
                    break;
                    
                case 'config':
                    await this.loadConfigPlugin(plugin);
                    break;
                    
                case 'widget':
                    await this.loadWidgetPlugin(plugin);
                    break;
                    
                default:
                    // Auto-detect type by extension
                    await this.autoDetectAndLoad(plugin);
            }
            
            this.pluginRegistry.set(plugin.name, {
                ...plugin,
                loaded: true,
                loadTime: new Date()
            });
            
        } catch (error) {
            this.log(`Failed to load plugin: ${plugin.name} - ${error.message}`, 'error');
            this.pluginRegistry.set(plugin.name, {
                ...plugin,
                loaded: false,
                error: error.message
            });
        }
    }

    async loadScriptPlugin(plugin) {
        await this.loadScriptWithRetry(plugin.url);
        this.pluginsLoaded++;
        this.log(`✅ Script plugin loaded: ${plugin.name}`, 'success');
        
        // Initialize plugin if it has an init function
        if (typeof window[`init${plugin.name.replace(/\s+/g, '')}`] === 'function') {
            try {
                window[`init${plugin.name.replace(/\s+/g, '')}`]();
                this.log(`🔧 Plugin initialized: ${plugin.name}`, 'success');
            } catch (e) {
                this.log(`⚠️ Plugin init failed: ${plugin.name}`, 'warn');
            }
        }
    }

    async loadStylePlugin(plugin) {
        await this.loadCSSWithRetry(plugin.url);
        this.pluginsLoaded++;
        this.log(`🎨 Style plugin loaded: ${plugin.name}`, 'success');
    }

    async loadConfigPlugin(plugin) {
        const config = await this.fetchJSON(plugin.url);
        if (config && typeof config === 'object') {
            // Store config in global namespace
            window[`config${plugin.name.replace(/\s+/g, '')}`] = config;
            this.pluginsLoaded++;
            this.log(`⚙️ Config plugin loaded: ${plugin.name}`, 'success');
        } else {
            throw new Error('Invalid JSON configuration');
        }
    }

    async loadWidgetPlugin(plugin) {
        const html = await this.fetchText(plugin.url);
        const widgetContainer = document.createElement('div');
        widgetContainer.innerHTML = html;
        widgetContainer.setAttribute('data-plugin-widget', plugin.name);
        widgetContainer.style.cssText = 'position: fixed; z-index: 10000;';
        document.body.appendChild(widgetContainer);
        this.pluginsLoaded++;
        this.log(`🧩 Widget plugin loaded: ${plugin.name}`, 'success');
    }

    async autoDetectAndLoad(plugin) {
        const url = plugin.url.toLowerCase();
        if (url.endsWith('.js')) {
            await this.loadScriptPlugin(plugin);
        } else if (url.endsWith('.css')) {
            await this.loadStylePlugin(plugin);
        } else if (url.endsWith('.json')) {
            await this.loadConfigPlugin(plugin);
        } else if (url.endsWith('.html')) {
            await this.loadWidgetPlugin(plugin);
        } else {
            // Default to script
            await this.loadScriptPlugin(plugin);
        }
    }

    async loadScriptWithRetry(url, attempt = 0) {
        try {
            await this.loadScript(url);
        } catch (error) {
            if (attempt < this.config.retryAttempts) {
                this.log(`Retrying script load (${attempt + 1}/${this.config.retryAttempts}): ${url}`, 'warn');
                await this.delay(this.config.retryDelay * (attempt + 1));
                return this.loadScriptWithRetry(url, attempt + 1);
            }
            throw error;
        }
    }

    async loadCSSWithRetry(url, attempt = 0) {
        try {
            await this.loadCSS(url);
        } catch (error) {
            if (attempt < this.config.retryAttempts) {
                this.log(`Retrying CSS load (${attempt + 1}/${this.config.retryAttempts}): ${url}`, 'warn');
                await this.delay(this.config.retryDelay * (attempt + 1));
                return this.loadCSSWithRetry(url, attempt + 1);
            }
            throw error;
        }
    }

    loadScript(url) {
        return new Promise((resolve, reject) => {
            if (typeof GM?.xmlHttpRequest !== 'function') {
                reject(new Error('GM.xmlHttpRequest is not available'));
                return;
            }

            GM.xmlHttpRequest({
                method: 'GET',
                url: url,
                timeout: this.config.timeout,
                responseType: 'text',
                onload: (response) => {
                    if (response.status >= 200 && response.status < 300) {
                        try {
                            const script = document.createElement('script');
                            script.textContent = response.responseText;
                            script.setAttribute('data-plugin-url', url);
                            script.setAttribute('data-loaded-by', 'UniversalPluginLoader');
                            script.setAttribute('type', 'text/javascript');
                            
                            script.onerror = (e) => {
                                this.log(`Script execution error: ${url}`, 'error');
                            };
                            
                            document.head.appendChild(script);
                            resolve(response);
                        } catch (e) {
                            reject(new Error(`Script execution failed: ${e.message}`));
                        }
                    } else {
                        reject(new Error(`HTTP ${response.status}: ${response.statusText}`));
                    }
                },
                onerror: (error) => reject(new Error(`Network error: ${error}`)),
                ontimeout: () => reject(new Error('Request timeout'))
            });
        });
    }

    loadCSS(url) {
        return new Promise((resolve, reject) => {
            if (typeof GM?.xmlHttpRequest !== 'function') {
                reject(new Error('GM.xmlHttpRequest is not available'));
                return;
            }

            GM.xmlHttpRequest({
                method: 'GET',
                url: url,
                timeout: this.config.timeout,
                responseType: 'text',
                onload: (response) => {
                    if (response.status >= 200 && response.status < 300) {
                        try {
                            if (typeof GM.addStyle === 'function') {
                                GM.addStyle(response.responseText);
                            } else {
                                const style = document.createElement('style');
                                style.textContent = response.responseText;
                                style.setAttribute('data-plugin-url', url);
                                document.head.appendChild(style);
                            }
                            resolve(response);
                        } catch (e) {
                            reject(new Error(`CSS application failed: ${e.message}`));
                        }
                    } else {
                        reject(new Error(`HTTP ${response.status}: ${response.statusText}`));
                    }
                },
                onerror: (error) => reject(new Error(`Network error: ${error}`)),
                ontimeout: () => reject(new Error('Request timeout'))
            });
        });
    }

    async fetchJSON(url) {
        const response = await this.fetchText(url);
        return JSON.parse(response);
    }

    fetchText(url) {
        return new Promise((resolve, reject) => {
            GM.xmlHttpRequest({
                method: 'GET',
                url: url,
                timeout: this.config.timeout,
                onload: (response) => {
                    if (response.status >= 200 && response.status < 300) {
                        resolve(response.responseText);
                    } else {
                        reject(new Error(`HTTP ${response.status}: ${response.statusText}`));
                    }
                },
                onerror: reject,
                ontimeout: () => reject(new Error('Request timeout'))
            });
        });
    }

    // Plugin Manager UI
    async injectPluginManager() {
        if (!this.config.enablePluginManager) return;

        try {
            this.createStatusIndicator();
            this.createPluginManagerPanel();
            this.log('Plugin manager injected successfully', 'success');
        } catch (error) {
            this.handleError('Failed to inject plugin manager', error);
        }
    }

    createStatusIndicator() {
        if (!document.body) {
            this.log('Document body not available for status indicator', 'warn');
            return;
        }

        try {
            const indicator = document.createElement('div');
            indicator.innerHTML = `
                <div class="universal-plugin-indicator">
                    <div class="plugin-stats">
                        <span class="plugin-icon">🔌</span>
                        <span class="plugin-count">${this.pluginsLoaded}/${this.totalPlugins}</span>
                    </div>
                    <div class="plugin-status">PLUGINS ACTIVE</div>
                </div>
            `;

            const style = `
                .universal-plugin-indicator {
                    position: fixed;
                    top: 20px;
                    right: 20px;
                    z-index: 10000;
                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                    color: white;
                    padding: 12px 16px;
                    border-radius: 12px;
                    font-family: 'Segoe UI', system-ui, sans-serif;
                    font-size: 12px;
                    box-shadow: 0 4px 12px rgba(0,0,0,0.15);
                    backdrop-filter: blur(10px);
                    border: 1px solid rgba(255,255,255,0.2);
                    cursor: pointer;
                    transition: all 0.3s ease;
                    user-select: none;
                }
                
                .universal-plugin-indicator:hover {
                    transform: translateY(-2px);
                    box-shadow: 0 6px 20px rgba(0,0,0,0.2);
                }
                
                .plugin-stats {
                    display: flex;
                    align-items: center;
                    gap: 8px;
                    margin-bottom: 4px;
                }
                
                .plugin-icon {
                    font-size: 14px;
                }
                
                .plugin-count {
                    font-weight: 600;
                    font-size: 14px;
                }
                
                .plugin-status {
                    opacity: 0.9;
                    font-size: 10px;
                    letter-spacing: 0.5px;
                }
            `;

            try {
                if (typeof GM.addStyle === 'function') {
                    GM.addStyle(style);
                } else {
                    const styleElement = document.createElement('style');
                    styleElement.textContent = style;
                    document.head.appendChild(styleElement);
                }
            } catch (styleError) {
                this.log('Failed to add status indicator styles', 'warn');
            }

            document.body.appendChild(indicator);
            indicator.addEventListener('click', this.openPluginManager);
            
        } catch (error) {
            this.handleError('Failed to create status indicator', error);
        }
    }

    createPluginManagerPanel() {
        // Advanced plugin manager UI
        const panel = document.createElement('div');
        panel.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background: white;
            border-radius: 12px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.3);
            z-index: 10001;
            padding: 20px;
            min-width: 500px;
            max-height: 80vh;
            overflow-y: auto;
            font-family: 'Segoe UI', sans-serif;
            display: none;
        `;

        panel.innerHTML = `
            <div class="plugin-manager">
                <h2 style="margin: 0 0 20px 0; color: #333;">🔌 Plugin Manager</h2>
                <div class="plugins-list">
                    ${this.plugins.map(plugin => `
                        <div class="plugin-item" data-plugin-name="${plugin.name}">
                            <div class="plugin-info">
                                <h3>${plugin.name}</h3>
                                <p>${plugin.description || 'No description'}</p>
                                <small>Type: ${plugin.type} | URL: ${plugin.url}</small>
                            </div>
                            <div class="plugin-controls">
                                <button class="toggle-btn ${plugin.enabled ? 'enabled' : 'disabled'}">
                                    ${plugin.enabled ? 'Disable' : 'Enable'}
                                </button>
                                <span class="status ${this.pluginRegistry.get(plugin.name)?.loaded ? 'loaded' : 'failed'}">
                                    ${this.pluginRegistry.get(plugin.name)?.loaded ? '✅' : '❌'}
                                </span>
                            </div>
                        </div>
                    `).join('')}
                </div>
                <div style="margin-top: 20px; text-align: right;">
                    <button id="close-plugin-manager" style="padding: 8px 16px; background: #667eea; color: white; border: none; border-radius: 6px; cursor: pointer;">
                        Close
                    </button>
                </div>
            </div>
        `;

        document.body.appendChild(panel);

        // Add panel styles
        const panelStyle = `
            .plugin-manager {
                color: #333;
            }
            .plugins-list {
                max-height: 400px;
                overflow-y: auto;
            }
            .plugin-item {
                display: flex;
                justify-content: space-between;
                align-items: center;
                padding: 12px;
                border: 1px solid #ddd;
                border-radius: 8px;
                margin-bottom: 8px;
                background: #f9f9f9;
            }
            .plugin-info h3 {
                margin: 0 0 5px 0;
                font-size: 14px;
            }
            .plugin-info p {
                margin: 0 0 5px 0;
                font-size: 12px;
                color: #666;
            }
            .plugin-info small {
                color: #999;
            }
            .toggle-btn {
                padding: 6px 12px;
                border: none;
                border-radius: 4px;
                cursor: pointer;
                font-size: 12px;
            }
            .toggle-btn.enabled {
                background: #4CAF50;
                color: white;
            }
            .toggle-btn.disabled {
                background: #f44336;
                color: white;
            }
        `;

        GM.addStyle(panelStyle);

        // Event listeners
        panel.querySelector('#close-plugin-manager').addEventListener('click', () => {
            panel.style.display = 'none';
        });

        // Toggle buttons
        panel.querySelectorAll('.toggle-btn').forEach(btn => {
            btn.addEventListener('click', (e) => {
                const pluginName = e.target.closest('.plugin-item').dataset.pluginName;
                this.togglePlugin(pluginName);
            });
        });
    }

    openPluginManager() {
        const panel = document.querySelector('.plugin-manager')?.closest('div');
        if (panel) {
            panel.style.display = 'block';
        }
    }

    togglePlugin(pluginName) {
        this.log(`Toggling plugin: ${pluginName}`, 'info');
        // Implementation for dynamically enabling/disabling plugins
        // This would require more advanced state management
    }

    // Utility methods
    isValidUrl(string) {
        try {
            new URL(string);
            return true;
        } catch (_) {
            return false;
        }
    }

    delay(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    log(message, type = 'info') {
        const emojis = { info: 'ℹ️', success: '✅', warn: '⚠️', error: '❌' };
        const emoji = emojis[type] || '📝';
        const styles = { info: 'color: blue;', success: 'color: green;', warn: 'color: orange;', error: 'color: red;' };
        console.log(`%c${emoji} Aternos Plugin Loader: ${message}`, styles[type] || '');
    }

    handleError(context, error) {
        this.log(`${context}: ${error?.message || error}`, 'error');
        console.error(context, error);
    }

    handlePromiseRejection(event) {
        this.log(`Unhandled promise rejection: ${event.reason}`, 'error');
    }

    setupErrorHandling() {
        window.addEventListener('error', (event) => {
            if (event.target?.tagName === 'SCRIPT' && event.target.hasAttribute('data-plugin-url')) {
                this.log(`Runtime error in plugin: ${event.target.getAttribute('data-plugin-url')}`, 'error');
            }
        });

        window.addEventListener('unhandledrejection', this.handlePromiseRejection);
    }
}

// Initialize the universal plugin loader
(async function() {
    'use strict';
    
    if (window.aternosPluginLoaderInstance) {
        console.log('Aternos Plugin Loader already running');
        return;
    }
    
    try {
        if (document.readyState === 'loading') {
            await new Promise(resolve => 
                document.addEventListener('DOMContentLoaded', resolve, { once: true })
            );
        }
        
        await new Promise(resolve => setTimeout(resolve, 100));
        
        const loader = new UniversalPluginLoader();
        window.aternosPluginLoaderInstance = loader;
        await loader.init();
        
    } catch (error) {
        console.error('🚨 Aternos Universal Plugin Loader: Critical initialization error', error);
    }
})();