stonecut-map-builder 0.0.0-stage → 0.1.0

package/dist/mc/java.js

@@ -0,0 +1,97 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+export const JAVA_SOURCES = [
+    { name: 'Eclipse Temurin (Adoptium)', url: 'https://adoptium.net/temurin/releases/' },
+    { name: 'Microsoft Build of OpenJDK', url: 'https://learn.microsoft.com/java/openjdk/download' },
+];
+export function javaInstallHint(major, platform = process.platform) {
+    const hints = JAVA_SOURCES.map((s) => `${s.name}, Java ${major}: ${s.url}`);
+    if (platform === 'win32')
+        hints.push(`Windows terminal: winget install EclipseAdoptium.Temurin.${major}.JRE`);
+    else if (platform === 'darwin')
+        hints.push(`macOS with Homebrew: brew install --cask temurin@${major}`);
+    else
+        hints.push(`Linux: your package manager, for example sudo apt install openjdk-${major}-jre-headless`);
+    return hints;
+}
+export function parseJavaVersion(output) {
+    const m = /version "([^"]+)"/.exec(output);
+    if (!m)
+        return null;
+    const v = m[1];
+    const parts = v.split(/[._+-]/).map((n) => parseInt(n, 10));
+    const major = parts[0] === 1 ? parts[1] : parts[0];
+    return Number.isFinite(major) ? { major, version: v } : null;
+}
+function exe() {
+    return process.platform === 'win32' ? 'java.exe' : 'java';
+}
+function subdirs(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join(dir, d.name));
+    }
+    catch {
+        return [];
+    }
+}
+/** Places Java is commonly installed, built from environment variables and the home folder only. */
+export function candidatePaths(env = process.env, home = homedir()) {
+    const out = [];
+    const bin = (dir) => join(dir, 'bin', exe());
+    if (env.JAVA_HOME)
+        out.push(bin(env.JAVA_HOME));
+    for (const p of (env.PATH ?? env.Path ?? '').split(delimiter))
+        if (p)
+            out.push(join(p, exe()));
+    const vendorRoots = [];
+    if (process.platform === 'win32') {
+        for (const pf of [env.ProgramFiles, env['ProgramFiles(x86)']]) {
+            if (!pf)
+                continue;
+            for (const v of ['Java', 'Eclipse Adoptium', 'Microsoft', 'Zulu', 'Amazon Corretto', 'BellSoft', 'Semeru', 'OpenJDK'])
+                vendorRoots.push(join(pf, v));
+        }
+    }
+    else if (process.platform === 'darwin') {
+        for (const root of ['/Library/Java/JavaVirtualMachines', join(home, 'Library', 'Java', 'JavaVirtualMachines')]) {
+            for (const d of subdirs(root))
+                out.push(bin(join(d, 'Contents', 'Home')));
+        }
+    }
+    else {
+        vendorRoots.push('/usr/lib/jvm', '/usr/java', '/opt/java');
+    }
+    vendorRoots.push(join(home, '.jdks'), join(home, '.sdkman', 'candidates', 'java'));
+    for (const root of vendorRoots)
+        for (const d of subdirs(root))
+            out.push(bin(d));
+    return [...new Set(out)];
+}
+export function probeJava(path) {
+    return new Promise((resolve) => {
+        execFile(path, ['-version'], { timeout: 15_000, windowsHide: true }, (err, stdout, stderr) => {
+            if (err && !stderr)
+                return resolve(null);
+            const v = parseJavaVersion(`${stderr}\n${stdout}`);
+            resolve(v ? { path, ...v } : null);
+        });
+    });
+}
+export async function findJava(extra = [], env = process.env, home = homedir()) {
+    const paths = [...extra, ...candidatePaths(env, home)].filter((p) => existsSync(p));
+    const found = await Promise.all(paths.map(probeJava));
+    const seen = new Set();
+    return found.filter((j) => {
+        if (!j || seen.has(j.path.toLowerCase()))
+            return false;
+        seen.add(j.path.toLowerCase());
+        return true;
+    });
+}
+/** The best Java for a required major version: the exact version if present, otherwise the lowest newer one. */
+export function pickJava(found, major) {
+    const ok = found.filter((j) => j.major >= major).sort((a, b) => a.major - b.major);
+    return ok.find((j) => j.major === major) ?? ok[0] ?? null;
+}

package/dist/mc/properties.js

@@ -0,0 +1,149 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isLoopback, RCON_HOST } from '../safety/address.js';
+export class PropertiesError extends Error {
+}
+/** Java's whitespace in properties files: space, tab and form feed. */
+const SPACE = new Set([' ', '\t', '\f']);
+const ESCAPES = { t: '\t', n: '\n', r: '\r', f: '\f' };
+function unescape(s, line) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c !== '\\' || i + 1 >= s.length) {
+            out += c;
+            continue;
+        }
+        const n = s[++i];
+        if (n === 'u') {
+            const hex = s.slice(i + 1, i + 5);
+            if (!/^[0-9a-fA-F]{4}$/.test(hex))
+                throw new PropertiesError(`server.properties line ${line} has a broken \\u escape, so Minecraft cannot read the file either. Fix that line.`);
+            out += String.fromCharCode(parseInt(hex, 16));
+            i += 4;
+        }
+        else
+            out += ESCAPES[n] ?? n;
+    }
+    return out;
+}
+function escape(s) {
+    return s.replace(/\\/g, '\\\\').replace(/([:=#!])/g, '\\$1').replace(/^ /, '\\ ');
+}
+function skipSpace(s) {
+    let i = 0;
+    while (i < s.length && SPACE.has(s[i]))
+        i++;
+    return s.slice(i);
+}
+function continues(s) {
+    let n = 0;
+    while (n < s.length && s[s.length - 1 - n] === '\\')
+        n++;
+    return n % 2 === 1;
+}
+function entries(lines) {
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        let part = skipSpace(lines[i]);
+        if (part === '' || part[0] === '#' || part[0] === '!')
+            continue;
+        const first = i;
+        let text = '';
+        while (continues(part) && i + 1 < lines.length) {
+            text += part.slice(0, -1);
+            part = skipSpace(lines[++i]);
+        }
+        text += continues(part) ? part.slice(0, -1) : part;
+        // The key ends at the first unescaped =, : or whitespace; after whitespace one = or : may follow.
+        let k = 0;
+        let valueStart = text.length;
+        let hasSep = false;
+        let escaped = false;
+        for (; k < text.length; k++) {
+            const c = text[k];
+            if (!escaped && (c === '=' || c === ':' || SPACE.has(c))) {
+                hasSep = !SPACE.has(c);
+                valueStart = k + 1;
+                break;
+            }
+            escaped = c === '\\' ? !escaped : false;
+        }
+        while (valueStart < text.length) {
+            const c = text[valueStart];
+            if (!SPACE.has(c)) {
+                if (hasSep || (c !== '=' && c !== ':'))
+                    break;
+                hasSep = true;
+            }
+            valueStart++;
+        }
+        out.push({ key: unescape(text.slice(0, k), first + 1), value: unescape(text.slice(valueStart), first + 1), first, last: i });
+    }
+    return out;
+}
+const physicalLines = (text) => text.split(/\r\n|\r|\n/);
+export function parseProperties(text) {
+    const out = new Map();
+    for (const e of entries(physicalLines(text)))
+        out.set(e.key, e.value);
+    return out;
+}
+export function updateProperties(text, changes) {
+    const lines = physicalLines(text);
+    const left = new Map(Object.entries(changes));
+    for (const e of entries(lines)) {
+        if (!Object.hasOwn(changes, e.key))
+            continue;
+        lines[e.first] = `${e.key}=${escape(changes[e.key])}`;
+        for (let i = e.first + 1; i <= e.last; i++)
+            lines[i] = null;
+        left.delete(e.key);
+    }
+    const kept = lines.filter((l) => l !== null);
+    while (kept.length && kept[kept.length - 1] === '')
+        kept.pop();
+    for (const [k, v] of left)
+        kept.push(`${k}=${escape(v)}`);
+    return `${kept.join('\n')}\n`;
+}
+export function propertiesFile(serverDir) {
+    return join(serverDir, 'server.properties');
+}
+export function readProperties(serverDir) {
+    const f = propertiesFile(serverDir);
+    return existsSync(f) ? parseProperties(readFileSync(f, 'utf8')) : new Map();
+}
+export function newPassword() {
+    return randomBytes(24).toString('base64url');
+}
+/** Settings the tool always keeps: local only, RCON on, no query port, no RCON echo to players. */
+export function lockedChanges(props, rconPort) {
+    const pw = props.get('rcon.password') ?? '';
+    const management = props.get('management-server-host');
+    return {
+        'server-ip': isLoopback(props.get('server-ip') ?? '') ? props.get('server-ip') : RCON_HOST,
+        'enable-rcon': 'true',
+        'rcon.port': String(rconPort),
+        'rcon.password': pw.length >= 20 ? pw : newPassword(),
+        'enable-query': 'false',
+        'broadcast-rcon-to-ops': 'false',
+        // Minecraft 1.21.9 and newer has a management server, off by default; when it is set up it stays local too.
+        ...(management !== undefined && !isLoopback(management) ? { 'management-server-host': RCON_HOST } : {}),
+    };
+}
+/** Rewrites the locked settings if anything changed them. Returns the keys it had to fix. */
+export function enforceLocked(serverDir, rconPort) {
+    const f = propertiesFile(serverDir);
+    const text = existsSync(f) ? readFileSync(f, 'utf8') : '';
+    const props = parseProperties(text);
+    const changes = lockedChanges(props, rconPort);
+    const fixed = Object.entries(changes).filter(([k, v]) => props.get(k) !== v).map(([k]) => k);
+    if (fixed.length)
+        writeFileSync(f, updateProperties(text, changes));
+    return fixed;
+}
+export function redactProperties(text) {
+    return text.replace(/^(\s*(?:rcon\.password|management-server-secret)\s*[=:]).*$/gm, '$1<hidden>');
+}

package/dist/mc/setup.js

@@ -0,0 +1,167 @@
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join } from 'node:path';
+import { checkAllowedFolder } from '../safety/paths.js';
+import { downloadFile } from './download.js';
+import { findJava, javaInstallHint, pickJava } from './java.js';
+import { newPassword, updateProperties } from './properties.js';
+import { findFreePort, portFree, STATE_DIR, writeEula, writeMeta } from './testserver.js';
+import { EULA_URL, neoforgeSha256, resolveNeoForge, resolveVersion, serverDownload } from './versions.js';
+const PLAN_LIFETIME_MS = 30 * 60_000;
+const NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
+export class SetupError extends Error {
+}
+/**
+ * A Java the agent names must be a program called java (java.exe) given by full path, and not inside
+ * a server folder: the file tools can write there, and the tool runs this program.
+ */
+export function checkJavaPath(config, path) {
+    const name = basename(path).toLowerCase();
+    if (!isAbsolute(path) || (name !== 'java' && name !== 'java.exe'))
+        throw new SetupError(`java_path must be the full path of a program called java or java.exe, not ${path}`);
+    let inServerFolder = true;
+    try {
+        checkAllowedFolder(config.serverFolders, path);
+    }
+    catch {
+        inServerFolder = false;
+    }
+    if (inServerFolder)
+        throw new SetupError(`java_path cannot be inside a server folder: ${path}. Use a Java installed on this computer.`);
+}
+export async function planSetup(config, input) {
+    if (!NAME.test(input.name))
+        throw new SetupError('Server name: 1-40 characters of A-Z a-z 0-9 _ -, starting with a letter or digit');
+    const root = input.serverFolder ?? config.serverFolders[0];
+    checkAllowedFolder(config.serverFolders, root);
+    const folder = checkAllowedFolder(config.serverFolders, join(root, input.name));
+    if (existsSync(folder) && readdirSync(folder).length > 0)
+        throw new SetupError(`${folder} already exists and is not empty. Pick another name, or use_server to use it.`);
+    if (input.javaPath)
+        checkJavaPath(config, input.javaPath);
+    const entry = await resolveVersion(input.minecraft);
+    const server = await serverDownload(entry);
+    const downloads = [];
+    let loaderVersion;
+    let loaderIsBeta;
+    if (input.loader === 'vanilla') {
+        downloads.push({ what: `Minecraft ${entry.id} server`, url: server.url, source: 'Mojang (official version manifest)', hash: { algo: 'sha1', value: server.sha1 }, size: server.size });
+    }
+    else {
+        const build = await resolveNeoForge(entry.id);
+        loaderVersion = build.version;
+        loaderIsBeta = build.beta;
+        downloads.push({ what: `NeoForge ${build.version} installer`, url: build.installerUrl, source: 'NeoForged (maven.neoforged.net)', hash: { algo: 'sha256', value: await neoforgeSha256(build) } });
+        downloads.push({ what: `Minecraft ${entry.id} server and NeoForge libraries, fetched and hash-checked by the NeoForge installer`, url: 'https://piston-data.mojang.com and https://maven.neoforged.net', source: 'Mojang and NeoForged', hash: { algo: 'sha1', value: server.sha1 } });
+    }
+    const extra = [input.javaPath, config.javaPath].filter((p) => !!p);
+    const javaFound = await findJava(extra);
+    const java = input.javaPath ? javaFound.find((j) => j.path === input.javaPath && j.major >= server.javaMajor) ?? null : pickJava(javaFound, server.javaMajor);
+    const gamePort = input.gamePort ?? (await findFreePort(25565));
+    const rconPort = input.rconPort ?? (await findFreePort(25575, [gamePort]));
+    if (gamePort === rconPort)
+        throw new SetupError('Game port and RCON port must differ');
+    return {
+        planId: randomUUID(),
+        folder,
+        minecraft: entry.id,
+        loader: input.loader,
+        ...(loaderVersion ? { loaderVersion, loaderIsBeta } : {}),
+        javaNeeded: server.javaMajor,
+        java,
+        javaFound,
+        ...(java ? {} : { javaMissing: javaInstallHint(server.javaMajor) }),
+        downloads,
+        gamePort,
+        rconPort,
+        memoryMb: input.memoryMb ?? (input.loader === 'neoforge' ? 4096 : 2048),
+        worldType: input.worldType ?? 'flat',
+        eulaUrl: EULA_URL,
+        ready: java !== null,
+        expires: Date.now() + PLAN_LIFETIME_MS,
+    };
+}
+export function serverProperties(plan) {
+    return updateProperties('#Minecraft server properties, made by Stonecut Map Builder\n', {
+        'server-ip': '127.0.0.1',
+        'server-port': String(plan.gamePort),
+        'enable-rcon': 'true',
+        'rcon.port': String(plan.rconPort),
+        'rcon.password': newPassword(),
+        'broadcast-rcon-to-ops': 'false',
+        'enable-query': 'false',
+        'online-mode': 'true',
+        motd: 'Stonecut test server (this computer only)',
+        gamemode: 'creative',
+        difficulty: 'peaceful',
+        'level-type': plan.worldType === 'flat' ? 'minecraft:flat' : 'minecraft:normal',
+        'generate-structures': plan.worldType === 'flat' ? 'false' : 'true',
+        'spawn-protection': '0',
+        'max-players': '8',
+        'enable-command-block': 'true',
+        'allow-flight': 'true',
+    });
+}
+function run(java, args, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        execFile(java, args, { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
+            const out = `${stdout}\n${stderr}`;
+            if (err)
+                reject(new SetupError(`${err.message}\n${out.split(/\r?\n/).slice(-20).join('\n')}`));
+            else
+                resolve(out);
+        });
+    });
+}
+export async function createServer(plan) {
+    const began = Date.now();
+    if (Date.now() > plan.expires)
+        throw new SetupError('This plan has expired. Run plan_setup again and show the person the new plan.');
+    if (!plan.java)
+        throw new SetupError(`Java ${plan.javaNeeded} or newer is needed and was not found. Show the person: ${plan.javaMissing?.join('; ')}`);
+    if (existsSync(plan.folder) && readdirSync(plan.folder).length > 0)
+        throw new SetupError(`${plan.folder} is no longer empty`);
+    for (const p of [plan.gamePort, plan.rconPort])
+        if (!(await portFree(p)))
+            throw new SetupError(`Port ${p} is now in use; run plan_setup again`);
+    mkdirSync(join(plan.folder, STATE_DIR, 'downloads'), { recursive: true });
+    const downloaded = [];
+    let launch;
+    if (plan.loader === 'vanilla') {
+        const d = plan.downloads[0];
+        const r = await downloadFile(d.url, join(plan.folder, 'server.jar'), { algo: d.hash.algo, hash: d.hash.value, ...(d.size ? { size: d.size } : {}) });
+        downloaded.push({ what: d.what, ...r });
+        launch = { type: 'jar', jar: 'server.jar' };
+    }
+    else {
+        const d = plan.downloads[0];
+        const installer = join(plan.folder, STATE_DIR, 'downloads', 'neoforge-installer.jar');
+        const r = await downloadFile(d.url, installer, { algo: d.hash.algo, hash: d.hash.value });
+        downloaded.push({ what: d.what, ...r });
+        const out = await run(plan.java.path, ['-jar', installer, '--installServer', plan.folder], join(plan.folder, STATE_DIR, 'downloads'), 20 * 60_000);
+        writeFileSync(join(plan.folder, STATE_DIR, 'install.log'), out);
+        rmSync(installer, { force: true });
+        const artifact = plan.minecraft === '1.20.1' ? 'forge' : 'neoforge';
+        const libDir = `libraries/net/neoforged/${artifact}/${plan.loaderVersion}`;
+        if (!existsSync(join(plan.folder, libDir)))
+            throw new SetupError(`The NeoForge installer finished but ${libDir} is missing. See ${STATE_DIR}/install.log.`);
+        launch = { type: 'argfile', libDir };
+    }
+    writeFileSync(join(plan.folder, 'server.properties'), serverProperties(plan));
+    writeEula(plan.folder, false);
+    const meta = {
+        minecraft: plan.minecraft,
+        loader: plan.loader,
+        ...(plan.loaderVersion ? { loaderVersion: plan.loaderVersion } : {}),
+        javaPath: plan.java.path,
+        javaMajor: plan.java.major,
+        memoryMb: plan.memoryMb,
+        launch,
+        rconPort: plan.rconPort,
+        createdAt: new Date().toISOString(),
+        createdByTool: true,
+    };
+    writeMeta(plan.folder, meta);
+    return { folder: plan.folder, meta, downloaded, seconds: (Date.now() - began) / 1000 };
+}