@minecraft-docker/shared 1.6.0 → 1.6.2

package/dist/docker/index.d.ts

@@ -0,0 +1,125 @@
+import type { ContainerStatus, HealthStatus, ServerInfo, RouterInfo, PlatformStatus, ContainerStats, PlayerListResult, DetailedServerInfo, RouterDetailInfo } from '../types/index.js';
+/**
+ * Execute a command and return stdout
+ * Uses spawnSync to properly handle arguments with special characters
+ */
+export declare function execCommand(command: string, args: string[]): string;
+/**
+ * Check if Docker is available
+ */
+export declare function checkDocker(): boolean;
+/**
+ * Check if Docker Compose is available
+ */
+export declare function checkDockerCompose(): boolean;
+/**
+ * Get container status
+ */
+export declare function getContainerStatus(container: string): ContainerStatus;
+/**
+ * Get container health status
+ */
+export declare function getContainerHealth(container: string): HealthStatus;
+/**
+ * Check mc-router health via management API
+ * mc-router uses distroless image, so Docker healthcheck doesn't work
+ * Instead, we check the management API on localhost:25580
+ */
+export declare function getRouterHealthViaApi(): HealthStatus;
+/**
+ * Check if container exists
+ */
+export declare function containerExists(container: string): boolean;
+/**
+ * Get container's hostname label (mc-router.host)
+ */
+export declare function getContainerHostname(container: string): string;
+/**
+ * Get all minecraft server containers (mc-* except mc-router)
+ */
+export declare function getMcContainers(): string[];
+/**
+ * Get running minecraft server containers
+ */
+export declare function getRunningMcContainers(): string[];
+/**
+ * Get server info for a container
+ */
+export declare function getServerInfo(container: string): ServerInfo;
+/**
+ * Get router info
+ */
+export declare function getRouterInfo(): RouterInfo;
+/**
+ * Get avahi-daemon status
+ */
+export declare function getAvahiStatus(): string;
+/**
+ * Get full platform status
+ */
+export declare function getPlatformStatus(): PlatformStatus;
+/**
+ * Start a container
+ */
+export declare function startContainer(container: string): boolean;
+/**
+ * Stop a container
+ */
+export declare function stopContainer(container: string): boolean;
+/**
+ * Get container logs
+ */
+export declare function getContainerLogs(container: string, lines?: number): string;
+/**
+ * Execute a command asynchronously and return result
+ * For docker commands that need async/await pattern
+ */
+export declare function execCommandAsync(command: string, args: string[]): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Execute shell script with environment variables
+ */
+export declare function execScript(scriptPath: string, args: string[], env?: Record<string, string>): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Execute shell script with inherited stdio (interactive)
+ */
+export declare function execScriptInteractive(scriptPath: string, args: string[], env?: Record<string, string>): Promise<number>;
+/**
+ * Get container resource stats (memory, CPU)
+ */
+export declare function getContainerStats(container: string): ContainerStats | null;
+/**
+ * Get container uptime (time since start)
+ */
+export declare function getContainerUptime(container: string): {
+    uptime: string;
+    seconds: number;
+} | null;
+/**
+ * Get online players via RCON
+ */
+export declare function getOnlinePlayers(container: string): Promise<PlayerListResult | null>;
+/**
+ * Get detailed server info
+ */
+export declare function getDetailedServerInfo(container: string, configEnv?: Record<string, string>): DetailedServerInfo;
+/**
+ * Get detailed server info with players (async)
+ */
+export declare function getDetailedServerInfoWithPlayers(container: string, configEnv?: Record<string, string>): Promise<DetailedServerInfo>;
+/**
+ * Get router detailed info
+ */
+export declare function getRouterDetailInfo(): RouterDetailInfo;
+/**
+ * Format bytes to human readable string
+ */
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/docker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/docker/index.ts"],"names":[],"mappings":"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"}

package/dist/docker/index.js

@@ -0,0 +1,557 @@
+import { spawn, execSync, spawnSync } from 'node:child_process';
+/**
+ * Execute a command and return stdout
+ * Uses spawnSync to properly handle arguments with special characters
+ */
+export function execCommand(command, args) {
+    try {
+        const result = spawnSync(command, args, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (result.error || result.status !== 0) {
+            return '';
+        }
+        return (result.stdout ?? '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Check if Docker is available
+ */
+export function checkDocker() {
+    try {
+        execSync('docker info', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if Docker Compose is available
+ */
+export function checkDockerCompose() {
+    try {
+        execSync('docker compose version', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get container status
+ */
+export function getContainerStatus(container) {
+    const result = execCommand('docker', [
+        'inspect',
+        '--format',
+        '{{.State.Status}}',
+        container,
+    ]);
+    if (!result)
+        return 'not_found';
+    return result;
+}
+/**
+ * Get container health status
+ */
+export function getContainerHealth(container) {
+    const result = execCommand('docker', [
+        'inspect',
+        '--format',
+        '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}',
+        container,
+    ]);
+    if (!result)
+        return 'unknown';
+    return result;
+}
+/**
+ * Check mc-router health via management API
+ * mc-router uses distroless image, so Docker healthcheck doesn't work
+ * Instead, we check the management API on localhost:25580
+ */
+export function getRouterHealthViaApi() {
+    try {
+        // Check if mc-router is running first
+        const status = getContainerStatus('mc-router');
+        if (status !== 'running') {
+            return 'unknown';
+        }
+        // Try to connect to management API
+        const result = spawnSync('curl', ['-s', '-o', '/dev/null', '-w', '%{http_code}', 'http://127.0.0.1:25580/routes'], {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (result.error || result.status !== 0) {
+            // curl failed, try wget
+            const wgetResult = spawnSync('wget', ['-q', '-O', '/dev/null', 'http://127.0.0.1:25580/routes'], {
+                encoding: 'utf-8',
+                timeout: 3000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            if (wgetResult.error || wgetResult.status !== 0) {
+                return 'unhealthy';
+            }
+            return 'healthy';
+        }
+        const httpCode = (result.stdout ?? '').trim();
+        if (httpCode === '200') {
+            return 'healthy';
+        }
+        return 'unhealthy';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Check if container exists
+ */
+export function containerExists(container) {
+    try {
+        execSync(`docker inspect ${container}`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get container's hostname label (mc-router.host)
+ */
+export function getContainerHostname(container) {
+    const result = execCommand('docker', [
+        'inspect',
+        '--format',
+        '{{index .Config.Labels "mc-router.host"}}',
+        container,
+    ]);
+    return result || '-';
+}
+/**
+ * Get all minecraft server containers (mc-* except mc-router)
+ */
+export function getMcContainers() {
+    const result = execCommand('docker', [
+        'ps',
+        '-a',
+        '--filter',
+        'name=mc-',
+        '--format',
+        '{{.Names}}',
+    ]);
+    if (!result)
+        return [];
+    return result
+        .split('\n')
+        .filter(name => name && name !== 'mc-router')
+        .sort();
+}
+/**
+ * Get running minecraft server containers
+ */
+export function getRunningMcContainers() {
+    const result = execCommand('docker', [
+        'ps',
+        '--filter',
+        'name=mc-',
+        '--filter',
+        'status=running',
+        '--format',
+        '{{.Names}}',
+    ]);
+    if (!result)
+        return [];
+    return result
+        .split('\n')
+        .filter(name => name && name !== 'mc-router')
+        .sort();
+}
+/**
+ * Get server info for a container
+ */
+export function getServerInfo(container) {
+    const serverName = container.replace(/^mc-/, '');
+    return {
+        name: serverName,
+        container,
+        status: getContainerStatus(container),
+        health: getContainerHealth(container),
+        hostname: getContainerHostname(container),
+    };
+}
+/**
+ * Get router info
+ */
+export function getRouterInfo() {
+    return {
+        name: 'mc-router',
+        status: getContainerStatus('mc-router'),
+        health: getRouterHealthViaApi(),
+        port: 25565,
+    };
+}
+/**
+ * Get avahi-daemon status
+ */
+export function getAvahiStatus() {
+    // Try systemctl first
+    try {
+        execSync('systemctl is-active --quiet avahi-daemon', { stdio: 'pipe' });
+        return 'running';
+    }
+    catch {
+        // Not running via systemctl
+    }
+    // Try OpenRC
+    try {
+        execSync('rc-service avahi-daemon status', { stdio: 'pipe' });
+        return 'running';
+    }
+    catch {
+        // Not running via OpenRC
+    }
+    // Check if installed
+    try {
+        execSync('which avahi-daemon', { stdio: 'pipe' });
+        return 'installed (not running)';
+    }
+    catch {
+        return 'not installed';
+    }
+}
+/**
+ * Get full platform status
+ */
+export function getPlatformStatus() {
+    const containers = getMcContainers();
+    return {
+        router: getRouterInfo(),
+        avahi_daemon: {
+            name: 'avahi-daemon',
+            status: getAvahiStatus(),
+            type: 'system',
+        },
+        servers: containers.map(getServerInfo),
+    };
+}
+/**
+ * Start a container
+ */
+export function startContainer(container) {
+    try {
+        execSync(`docker start ${container}`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Stop a container
+ */
+export function stopContainer(container) {
+    try {
+        execSync(`docker stop ${container}`, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get container logs
+ */
+export function getContainerLogs(container, lines = 50) {
+    return execCommand('docker', ['logs', '--tail', String(lines), container]);
+}
+/**
+ * Execute a command asynchronously and return result
+ * For docker commands that need async/await pattern
+ */
+export function execCommandAsync(command, args) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            resolve({ code: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+        });
+        child.on('error', () => {
+            resolve({ code: 1, stdout: '', stderr: 'Failed to execute command' });
+        });
+    });
+}
+/**
+ * Execute shell script with environment variables
+ */
+export function execScript(scriptPath, args, env = {}) {
+    return new Promise((resolve) => {
+        const child = spawn('bash', [scriptPath, ...args], {
+            env: { ...process.env, ...env },
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+            process.stdout.write(data);
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+            process.stderr.write(data);
+        });
+        child.on('close', (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on('error', () => {
+            resolve({ code: 1, stdout, stderr: 'Failed to execute script' });
+        });
+    });
+}
+/**
+ * Execute shell script with inherited stdio (interactive)
+ */
+export function execScriptInteractive(scriptPath, args, env = {}) {
+    return new Promise((resolve) => {
+        const child = spawn('bash', [scriptPath, ...args], {
+            env: { ...process.env, ...env },
+            stdio: 'inherit',
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 1);
+        });
+        child.on('error', () => {
+            resolve(1);
+        });
+    });
+}
+/**
+ * Get container resource stats (memory, CPU)
+ */
+export function getContainerStats(container) {
+    // docker stats --no-stream --format "{{.MemUsage}},{{.CPUPerc}}"
+    // Example output: "2.1GiB / 4GiB,15.23%"
+    const result = execCommand('docker', [
+        'stats',
+        '--no-stream',
+        '--format',
+        '{{.MemUsage}},{{.CPUPerc}}',
+        container,
+    ]);
+    if (!result)
+        return null;
+    try {
+        const [memUsage, cpuPerc] = result.split(',');
+        if (!memUsage || !cpuPerc)
+            return null;
+        // Parse memory: "2.1GiB / 4GiB" or "512MiB / 4GiB"
+        const memParts = memUsage.split('/').map((s) => s.trim());
+        if (memParts.length !== 2)
+            return null;
+        const parseMemory = (mem) => {
+            const match = mem.match(/^([\d.]+)\s*(B|KiB|MiB|GiB|TiB|KB|MB|GB|TB)?$/i);
+            if (!match || !match[1])
+                return 0;
+            const value = parseFloat(match[1]);
+            const unit = (match[2] ?? 'B').toUpperCase();
+            const multipliers = {
+                B: 1,
+                KIB: 1024,
+                MIB: 1024 ** 2,
+                GIB: 1024 ** 3,
+                TIB: 1024 ** 4,
+                KB: 1000,
+                MB: 1000 ** 2,
+                GB: 1000 ** 3,
+                TB: 1000 ** 4,
+            };
+            return value * (multipliers[unit] || 1);
+        };
+        const memoryUsage = parseMemory(memParts[0]);
+        const memoryLimit = parseMemory(memParts[1]);
+        const memoryPercent = memoryLimit > 0 ? (memoryUsage / memoryLimit) * 100 : 0;
+        // Parse CPU: "15.23%" or "0.00%"
+        const cpuPercent = parseFloat(cpuPerc.replace('%', '')) || 0;
+        return {
+            memoryUsage,
+            memoryLimit,
+            memoryPercent,
+            cpuPercent,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get container uptime (time since start)
+ */
+export function getContainerUptime(container) {
+    // docker inspect --format '{{.State.StartedAt}}'
+    const result = execCommand('docker', [
+        'inspect',
+        '--format',
+        '{{.State.StartedAt}}',
+        container,
+    ]);
+    if (!result || result === '0001-01-01T00:00:00Z')
+        return null;
+    try {
+        const startedAt = new Date(result);
+        const now = new Date();
+        const diffMs = now.getTime() - startedAt.getTime();
+        const diffSeconds = Math.floor(diffMs / 1000);
+        // Format uptime
+        const days = Math.floor(diffSeconds / 86400);
+        const hours = Math.floor((diffSeconds % 86400) / 3600);
+        const minutes = Math.floor((diffSeconds % 3600) / 60);
+        let uptime = '';
+        if (days > 0)
+            uptime += `${days}d `;
+        if (hours > 0 || days > 0)
+            uptime += `${hours}h `;
+        uptime += `${minutes}m`;
+        return { uptime: uptime.trim(), seconds: diffSeconds };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get online players via RCON
+ */
+export async function getOnlinePlayers(container) {
+    try {
+        const result = execSync(`docker exec ${container} rcon-cli list`, {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Parse: "There are 3 of a max of 20 players online: Notch, Steve, Alex"
+        // Or: "There are 0 of a max of 20 players online:"
+        const countMatch = result.match(/There are (\d+)(?:\s+of a max of\s+|\/)(\d+) players? online/i);
+        if (!countMatch || !countMatch[1] || !countMatch[2])
+            return null;
+        const online = parseInt(countMatch[1], 10);
+        const max = parseInt(countMatch[2], 10);
+        // Extract player names after the colon
+        const playersMatch = result.match(/:\s*(.*)$/);
+        let players = [];
+        if (playersMatch && playersMatch[1]) {
+            players = playersMatch[1]
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        return { online, max, players };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get detailed server info
+ */
+export function getDetailedServerInfo(container, configEnv) {
+    const basic = getServerInfo(container);
+    const detailed = { ...basic };
+    // Only get extended info if container is running
+    if (basic.status === 'running') {
+        // Get stats
+        const stats = getContainerStats(container);
+        if (stats) {
+            detailed.stats = stats;
+        }
+        // Get uptime
+        const uptimeInfo = getContainerUptime(container);
+        if (uptimeInfo) {
+            detailed.uptime = uptimeInfo.uptime;
+            detailed.uptimeSeconds = uptimeInfo.seconds;
+        }
+    }
+    // Get config info if provided
+    if (configEnv) {
+        detailed.type = configEnv['TYPE'];
+        detailed.version = configEnv['VERSION'];
+        detailed.memory = configEnv['MEMORY'];
+    }
+    return detailed;
+}
+/**
+ * Get detailed server info with players (async)
+ */
+export async function getDetailedServerInfoWithPlayers(container, configEnv) {
+    const detailed = getDetailedServerInfo(container, configEnv);
+    // Get players if running
+    if (detailed.status === 'running') {
+        const players = await getOnlinePlayers(container);
+        if (players) {
+            detailed.players = players;
+        }
+    }
+    return detailed;
+}
+/**
+ * Get router detailed info
+ */
+export function getRouterDetailInfo() {
+    const basic = getRouterInfo();
+    const detailed = {
+        ...basic,
+        routes: [],
+        mode: '--in-docker (auto-discovery)',
+    };
+    // Get uptime
+    if (basic.status === 'running') {
+        const uptimeInfo = getContainerUptime('mc-router');
+        if (uptimeInfo) {
+            detailed.uptime = uptimeInfo.uptime;
+            detailed.uptimeSeconds = uptimeInfo.seconds;
+        }
+    }
+    // Get routes from all mc-* containers
+    const containers = getMcContainers();
+    for (const container of containers) {
+        const hostname = getContainerHostname(container);
+        if (hostname && hostname !== '-') {
+            // hostname might be comma-separated (e.g., "server.local,server.192.168.1.10.nip.io")
+            const hostnames = hostname.split(',').map((h) => h.trim());
+            const serverStatus = getContainerStatus(container);
+            for (const h of hostnames) {
+                detailed.routes.push({
+                    hostname: h,
+                    target: `${container}:25565`,
+                    serverStatus,
+                });
+            }
+        }
+    }
+    return detailed;
+}
+/**
+ * Format bytes to human readable string
+ */
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+//# sourceMappingURL=index.js.map