347 lines
8.1 KiB
TypeScript
347 lines
8.1 KiB
TypeScript
import { spawn, $, write, file } from 'bun';
|
|
import { join } from 'path';
|
|
|
|
declare namespace Bun {
|
|
export const YAML: {
|
|
parse(text: string): any;
|
|
};
|
|
}
|
|
|
|
interface MinecraftEnvironment {
|
|
EULA: string;
|
|
VERSION?: string;
|
|
TYPE?: 'VANILLA' | 'FORGE' | 'FABRIC' | 'PAPER' | 'SPIGOT' | 'BUKKIT' | 'PURPUR' | 'MODDED';
|
|
DIFFICULTY?: 'PEACEFUL' | 'EASY' | 'NORMAL' | 'HARD';
|
|
MODE?: 'SURVIVAL' | 'CREATIVE' | 'ADVENTURE' | 'SPECTATOR';
|
|
MAX_PLAYERS?: string;
|
|
MOTD?: string;
|
|
LEVEL_NAME?: string;
|
|
SEED?: string;
|
|
PVP?: string;
|
|
ENABLE_COMMAND_BLOCK?: string;
|
|
SPAWN_PROTECTION?: string;
|
|
MAX_WORLD_SIZE?: string;
|
|
VIEW_DISTANCE?: string;
|
|
ONLINE_MODE?: string;
|
|
ALLOW_NETHER?: string;
|
|
ANNOUNCE_PLAYER_ACHIEVEMENTS?: string;
|
|
MEMORY?: string;
|
|
JVM_OPTS?: string;
|
|
[key: string]: string | undefined;
|
|
}
|
|
|
|
interface MinecraftService {
|
|
image: 'itzg/minecraft-server';
|
|
container_name: string;
|
|
tty: true;
|
|
stdin_open: true;
|
|
ports: string[];
|
|
environment: MinecraftEnvironment;
|
|
volumes: ['./data:/data'];
|
|
restart?: 'unless-stopped' | 'no';
|
|
networks?: string[];
|
|
}
|
|
|
|
// simple YAML stringifier for basic objects
|
|
function stringifyYAML(obj: any, indent = 0): string {
|
|
const spaces = ' '.repeat(indent);
|
|
|
|
if (obj === null || obj === undefined) {
|
|
return 'null';
|
|
}
|
|
|
|
if (typeof obj === 'string') {
|
|
// handle strings that need quoting
|
|
if (obj.includes(':') || obj.includes('\n') || obj.includes('#')) {
|
|
return `"${obj.replace(/"/g, '\\"')}"`;
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
if (typeof obj === 'number' || typeof obj === 'boolean') {
|
|
return String(obj);
|
|
}
|
|
|
|
if (Array.isArray(obj)) {
|
|
if (obj.length === 0) return '[]';
|
|
return obj.map((item) => `${spaces}- ${stringifyYAML(item, indent + 2)}`).join('\n');
|
|
}
|
|
|
|
if (typeof obj === 'object') {
|
|
const entries = Object.entries(obj);
|
|
if (entries.length === 0) return '{}';
|
|
|
|
return entries
|
|
.map(([key, value]) => {
|
|
if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
|
|
return `${spaces}${key}:\n${stringifyYAML(value, indent + 2)}`;
|
|
} else {
|
|
return `${spaces}${key}: ${stringifyYAML(value, 0)}`;
|
|
}
|
|
})
|
|
.join('\n');
|
|
}
|
|
|
|
return String(obj);
|
|
}
|
|
|
|
// minimal Minecraft docker-compose template
|
|
const baseTemplate: { services: { mc: MinecraftService } } = {
|
|
services: {
|
|
mc: {
|
|
image: 'itzg/minecraft-server',
|
|
container_name: 'minecraft',
|
|
tty: true,
|
|
stdin_open: true,
|
|
ports: ['25565:25565'],
|
|
environment: {
|
|
EULA: 'TRUE',
|
|
TYPE: 'PAPER',
|
|
ENABLE_WHITELIST: 'true',
|
|
WHITELIST: 'f396e2b9-cbb1-46a0-bb72-96898a1ca44d',
|
|
DIFFICULTY: 'NORMAL',
|
|
SPAWN_PROTECTION: '0',
|
|
RCON_CMDS_FIRST_CONNECT: `op vaporvee`
|
|
},
|
|
volumes: ['./data:/data']
|
|
}
|
|
}
|
|
};
|
|
|
|
const forbiddenKeys = new Set([
|
|
'ENABLE_QUERY',
|
|
'QUERY_PORT',
|
|
'ENABLE_RCON',
|
|
'RCON_PORT',
|
|
'RCON_PASSWORD'
|
|
]);
|
|
|
|
class ProjectManager {
|
|
constructor(private baseDir = join(process.cwd(), 'docker-projects')) {}
|
|
|
|
projectPath(name: string) {
|
|
return join(this.baseDir, name);
|
|
}
|
|
|
|
composePath(name: string) {
|
|
return join(this.projectPath(name), 'docker-compose.yml');
|
|
}
|
|
|
|
async createProject(name: string) {
|
|
await $`mkdir -p ${this.projectPath(name)}`;
|
|
await write(this.composePath(name), stringifyYAML(baseTemplate));
|
|
}
|
|
|
|
async patchProject(name: string, patch: any) {
|
|
const path = this.composePath(name);
|
|
const f = file(path);
|
|
if (!(await f.exists())) throw new Error('Project not found');
|
|
const text = await f.text();
|
|
const config = Bun.YAML.parse(text);
|
|
|
|
if (patch.services?.mc) {
|
|
for (const [key, val] of Object.entries(patch.services.mc)) {
|
|
if (!forbiddenKeys.has(key)) {
|
|
if (typeof val === 'object' && !Array.isArray(val)) {
|
|
config.services.mc[key] = { ...config.services.mc[key], ...val };
|
|
} else {
|
|
config.services.mc[key] = val;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
await write(path, stringifyYAML(config));
|
|
return config;
|
|
}
|
|
|
|
async overrideValue(name: string, key: string, value: string) {
|
|
const path = this.composePath(name);
|
|
const f = file(path);
|
|
if (!(await f.exists())) throw new Error('Project not found');
|
|
const text = await f.text();
|
|
const config = Bun.YAML.parse(text);
|
|
|
|
if (forbiddenKeys.has(key)) throw new Error(`Key ${key} cannot be overridden`);
|
|
if (!config.services.mc.environment) config.services.mc.environment = {};
|
|
config.services.mc.environment[key] = value;
|
|
|
|
await write(path, stringifyYAML(config));
|
|
return config;
|
|
}
|
|
|
|
async removeProject(name: string) {
|
|
const cwd = this.projectPath(name);
|
|
await spawn(['docker', 'compose', 'down', '-v'], { cwd }).exited;
|
|
await $`rm -rf ${cwd}`;
|
|
}
|
|
|
|
async runCompose(name: string, args: string[]) {
|
|
const cwd = this.projectPath(name);
|
|
const result = await spawn(['docker', 'compose', ...args], { cwd });
|
|
return result.exited;
|
|
}
|
|
|
|
async attach(name: string) {
|
|
const cwd = this.projectPath(name);
|
|
|
|
const process = spawn(['docker', 'exec', '-i', 'minecraft', 'rcon-cli'], {
|
|
cwd,
|
|
stdin: 'pipe',
|
|
stdout: 'pipe',
|
|
stderr: 'pipe'
|
|
});
|
|
|
|
const ansiColorMap: Record<string, string> = {
|
|
'30': 'black',
|
|
'31': 'red',
|
|
'32': 'green',
|
|
'33': 'yellow',
|
|
'34': 'blue',
|
|
'35': 'magenta',
|
|
'36': 'cyan',
|
|
'37': 'white',
|
|
'90': 'brightBlack',
|
|
'91': 'brightRed',
|
|
'92': 'brightGreen',
|
|
'93': 'brightYellow',
|
|
'94': 'brightBlue',
|
|
'95': 'brightMagenta',
|
|
'96': 'brightCyan',
|
|
'97': 'brightWhite'
|
|
};
|
|
|
|
function parseAnsiColors(text: string) {
|
|
const ansiRegex = /\x1b\[([0-9;]+)m/g;
|
|
const chunks: any[] = [];
|
|
let lastIndex = 0;
|
|
let match;
|
|
let currentColor: string | undefined;
|
|
let currentBold = false;
|
|
|
|
while ((match = ansiRegex.exec(text)) !== null) {
|
|
if (match.index > lastIndex) {
|
|
const textChunk = text.substring(lastIndex, match.index);
|
|
chunks.push({
|
|
text: textChunk,
|
|
color: currentColor,
|
|
bold: currentBold
|
|
});
|
|
}
|
|
|
|
const codes = match[1].split(';');
|
|
for (const code of codes) {
|
|
if (code === '0') {
|
|
currentColor = undefined;
|
|
currentBold = false;
|
|
chunks.push({ text: '', reset: true });
|
|
} else if (code === '1') {
|
|
currentBold = true;
|
|
} else if (ansiColorMap[code]) {
|
|
currentColor = ansiColorMap[code];
|
|
}
|
|
}
|
|
|
|
lastIndex = ansiRegex.lastIndex;
|
|
}
|
|
|
|
if (lastIndex < text.length) {
|
|
const textChunk = text.substring(lastIndex);
|
|
chunks.push({
|
|
text: textChunk,
|
|
color: currentColor,
|
|
bold: currentBold
|
|
});
|
|
}
|
|
|
|
return chunks;
|
|
}
|
|
|
|
const reader = new ReadableStream({
|
|
start(controller) {
|
|
const decoder = new TextDecoder();
|
|
let buffer = '';
|
|
|
|
const processOutput = async (stream: ReadableStream<Uint8Array>) => {
|
|
const reader = stream.getReader();
|
|
try {
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
|
|
buffer += decoder.decode(value, { stream: true });
|
|
|
|
const lines = buffer.split('\n');
|
|
buffer = lines.pop() || '';
|
|
|
|
for (const line of lines) {
|
|
const colorChunks = parseAnsiColors(line);
|
|
|
|
let formattedText = '';
|
|
for (const chunk of colorChunks) {
|
|
if (chunk.reset) {
|
|
continue;
|
|
}
|
|
|
|
let text = chunk.text;
|
|
if (text) {
|
|
if (chunk.color) {
|
|
if (chunk.bold) {
|
|
text = `<${chunk.color} font-bold>${text}</${chunk.color}>`;
|
|
} else {
|
|
text = `<${chunk.color}>${text}</${chunk.color}>`;
|
|
}
|
|
} else if (chunk.bold) {
|
|
text = `<span font-bold>${text}</span>`;
|
|
}
|
|
formattedText += text;
|
|
}
|
|
}
|
|
|
|
controller.enqueue({
|
|
type: 'output',
|
|
formatted: formattedText,
|
|
chunks: colorChunks,
|
|
rawText: line
|
|
});
|
|
}
|
|
}
|
|
} catch (error) {
|
|
controller.error(error);
|
|
} finally {
|
|
reader.releaseLock();
|
|
}
|
|
};
|
|
|
|
if (process.stdout) {
|
|
processOutput(process.stdout);
|
|
}
|
|
if (process.stderr) {
|
|
processOutput(process.stderr);
|
|
}
|
|
}
|
|
});
|
|
|
|
const writer = {
|
|
async write(text: string) {
|
|
if (process.stdin) {
|
|
await process.stdin.write(text);
|
|
}
|
|
},
|
|
async close() {
|
|
if (process.stdin) {
|
|
await process.stdin.end();
|
|
}
|
|
}
|
|
};
|
|
|
|
return {
|
|
reader,
|
|
writer,
|
|
process
|
|
};
|
|
}
|
|
}
|
|
|
|
export { ProjectManager };
|