Minerack API Documentation

class MinerackDashboard {
    constructor() {
        this.apiBase = 'https://minerack.net/api';
        this.csrfToken = null;
        this.isAuthenticated = false;
        this.init();
    }
    
    async init() {
        await this.getCsrfToken();
        await this.checkAuthStatus();
        this.setupEventListeners();
        this.startPolling();
    }
    
    async getCsrfToken() {
        try {
            const response = await fetch(`${this.apiBase}/csrf-token`, {
                credentials: 'include'
            });
            const data = await response.json();
            this.csrfToken = data.token;
        } catch (error) {
            console.error('Failed to get CSRF token:', error);
        }
    }
    
    async checkAuthStatus() {
        try {
            const response = await fetch(`${this.apiBase}/server-status`, {
                credentials: 'include'
            });
            this.isAuthenticated = response.ok;
            
            if (!this.isAuthenticated) {
                this.showLoginPrompt();
            }
        } catch (error) {
            console.error('Auth check failed:', error);
            this.isAuthenticated = false;
        }
    }
    
    async getServerStatus() {
        if (!this.isAuthenticated) return null;
        
        try {
            const response = await fetch(`${this.apiBase}/server-status`, {
                credentials: 'include'
            });
            
            if (response.ok) {
                return await response.json();
            }
        } catch (error) {
            console.error('Failed to get server status:', error);
        }
        return null;
    }
    
    async controlServer(action) {
        if (!this.isAuthenticated || !this.csrfToken) return;
        
        const validActions = ['start', 'stop', 'restart', 'kill'];
        if (!validActions.includes(action)) {
            console.error('Invalid server action:', action);
            return;
        }
        
        try {
            const response = await fetch(`${this.apiBase}/server-action`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    action: action,
                    csrf_token: this.csrfToken
                }),
                credentials: 'include'
            });
            
            const result = await response.json();
            this.showNotification(
                result.success ? `Server ${action} successful` : `Server ${action} failed: ${result.message}`,
                result.success ? 'success' : 'error'
            );
            
            // Refresh status after action
            setTimeout(() => this.updateDisplay(), 2000);
            
        } catch (error) {
            console.error('Server action failed:', error);
            this.showNotification(`Server ${action} failed`, 'error');
        }
    }
    
    async sendCommand(command) {
        if (!this.isAuthenticated || !this.csrfToken) return;
        
        try {
            const response = await fetch(`${this.apiBase}/send-command`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    command: command.trim(),
                    csrf_token: this.csrfToken
                }),
                credentials: 'include'
            });
            
            const result = await response.json();
            this.addToConsole(`> ${command}`);
            
            if (!result.success) {
                this.addToConsole(`Error: ${result.message}`);
            }
            
        } catch (error) {
            console.error('Command send failed:', error);
            this.addToConsole(`Error: Failed to send command`);
        }
    }
    
    async updateDisplay() {
        const status = await this.getServerStatus();
        if (!status || !status.success) return;
        
        const data = status.data;
        
        // Update status indicators
        this.updateElement('server-status', data.status);
        this.updateElement('player-count', `${data.players.current}/${data.players.max}`);
        this.updateElement('cpu-usage', `${Math.round(data.resources.cpu)}%`);
        this.updateElement('memory-usage', 
            `${Math.round(data.resources.memory.percentage)}%`);
        
        // Update status styling
        const statusElement = document.getElementById('server-status');
        if (statusElement) {
            statusElement.className = `status ${data.status}`;
        }
        
        // Enable/disable controls based on status
        this.updateControls(data.status);
    }
    
    updateControls(status) {
        const startBtn = document.getElementById('start-btn');
        const stopBtn = document.getElementById('stop-btn');
        const restartBtn = document.getElementById('restart-btn');
        
        if (startBtn) startBtn.disabled = (status === 'running' || status === 'starting');
        if (stopBtn) stopBtn.disabled = (status === 'offline' || status === 'stopping');
        if (restartBtn) restartBtn.disabled = (status === 'offline');
    }
    
    updateElement(id, value) {
        const element = document.getElementById(id);
        if (element) {
            element.textContent = value;
        }
    }
    
    addToConsole(message) {
        const console = document.getElementById('console-output');
        if (console) {
            const timestamp = new Date().toLocaleTimeString();
            console.innerHTML += `
[${timestamp}] ${message}
`;
            console.scrollTop = console.scrollHeight;
        }
    }
    
    showNotification(message, type = 'info') {
        // Create notification element
        const notification = document.createElement('div');
        notification.className = `notification ${type}`;
        notification.textContent = message;
        
        // Add to page
        document.body.appendChild(notification);
        
        // Auto-remove after 5 seconds
        setTimeout(() => {
            notification.remove();
        }, 5000);
    }
    
    showLoginPrompt() {
        this.showNotification('Please log in to access server controls', 'warning');
        // Redirect to login page or show login modal
    }
    
    setupEventListeners() {
        // Server control buttons
        document.getElementById('start-btn')?.addEventListener('click', 
            () => this.controlServer('start'));
        document.getElementById('stop-btn')?.addEventListener('click', 
            () => this.controlServer('stop'));
        document.getElementById('restart-btn')?.addEventListener('click', 
            () => this.controlServer('restart'));
        
        // Console command input
        const commandInput = document.getElementById('command-input');
        if (commandInput) {
            commandInput.addEventListener('keypress', (e) => {
                if (e.key === 'Enter') {
                    const command = commandInput.value.trim();
                    if (command) {
                        this.sendCommand(command);
                        commandInput.value = '';
                    }
                }
            });
        }
    }
    
    startPolling() {
        // Update display every 30 seconds
        setInterval(() => {
            if (this.isAuthenticated) {
                this.updateDisplay();
            }
        }, 30000);
        
        // Initial update
        this.updateDisplay();
    }
}

// Initialize dashboard when page loads
document.addEventListener('DOMContentLoaded', () => {
    window.minerackDashboard = new MinerackDashboard();
});

// HTML structure example:
/*

    

        
Server Status: Loading...
        
Players: 0/0
        
CPU: 0%
        
Memory: 0%
    
    
    

        Start
        Stop
        Restart
    
    
    

        

        
    



*/