stonecut-map-builder 0.0.0-stage → 0.1.0

package/dist/mc/testserver.js

@@ -0,0 +1,309 @@
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync, writeFileSync } from 'node:fs';
+import { connect, createServer } from 'node:net';
+import { uptime } from 'node:os';
+import { join } from 'node:path';
+import { RCON_HOST } from '../safety/address.js';
+import { resolveInside } from '../safety/paths.js';
+import { Rcon } from '../rcon/rcon.js';
+import { EULA_URL } from './versions.js';
+import { enforceLocked, readProperties } from './properties.js';
+// One local test server: its folder, how to launch it, and the RCON connections to it.
+export const STATE_DIR = '.stonecut';
+export const META_FILE = 'server.json';
+export class ServerError extends Error {
+}
+export function metaPath(dir) {
+    return join(dir, STATE_DIR, META_FILE);
+}
+export function writeMeta(dir, meta) {
+    mkdirSync(join(dir, STATE_DIR), { recursive: true });
+    writeFileSync(metaPath(dir), `${JSON.stringify(meta, null, 2)}\n`);
+}
+export function eulaAccepted(dir) {
+    const f = join(dir, 'eula.txt');
+    return existsSync(f) && /^\s*eula\s*=\s*true\s*$/im.test(readFileSync(f, 'utf8'));
+}
+export function writeEula(dir, accepted) {
+    writeFileSync(join(dir, 'eula.txt'), `#By changing the setting below to TRUE you are indicating your agreement to the Minecraft EULA (${EULA_URL}).\n` +
+        `#${accepted ? 'Accepted by the person through Stonecut Map Builder' : 'Not accepted yet'} on ${new Date().toISOString()}\n` +
+        `eula=${accepted}\n`);
+}
+/**
+ * True when no program on this computer uses the port. Listens on 127.0.0.1 for a moment (never on
+ * a network address, so no firewall question comes up) and tries to connect there, which also
+ * finds a program that listens on every address.
+ */
+export function portFree(port) {
+    const canListen = new Promise((resolve) => {
+        const s = createServer();
+        s.once('error', () => resolve(false));
+        s.listen({ host: RCON_HOST, port, exclusive: true }, () => s.close(() => resolve(true)));
+    });
+    const answers = () => new Promise((resolve) => {
+        const c = connect({ host: RCON_HOST, port });
+        const done = (open) => {
+            c.destroy();
+            resolve(open);
+        };
+        c.setTimeout(500, () => done(false));
+        c.once('connect', () => done(true));
+        c.once('error', () => done(false));
+    });
+    return canListen.then(async (free) => free && !(await answers()));
+}
+export async function findFreePort(start, avoid = []) {
+    for (let p = start; p < start + 200 && p <= 65535; p++) {
+        if (!avoid.includes(p) && (await portFree(p)))
+            return p;
+    }
+    throw new ServerError(`No free port found from ${start}`);
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function tail(file, lines) {
+    if (!existsSync(file))
+        return [];
+    const size = statSync(file).size;
+    const fd = openSync(file, 'r');
+    try {
+        const len = Math.min(size, 4 * 1024 * 1024);
+        const buf = Buffer.alloc(len);
+        readSync(fd, buf, 0, len, size - len);
+        const all = buf.toString('utf8').split(/\r?\n/);
+        if (all[all.length - 1] === '')
+            all.pop();
+        return all.slice(-lines);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export class TestServer {
+    dir;
+    meta;
+    conns = [];
+    childExit = null;
+    constructor(dir, meta) {
+        this.dir = dir;
+        this.meta = meta;
+    }
+    static open(dir) {
+        const f = metaPath(dir);
+        if (!existsSync(f))
+            throw new ServerError(`${dir} has no ${STATE_DIR}/${META_FILE}. Use use_server to adopt an existing server folder.`);
+        return new TestServer(dir, JSON.parse(readFileSync(f, 'utf8')));
+    }
+    get stateDir() {
+        return join(this.dir, STATE_DIR);
+    }
+    get pidFile() {
+        return join(this.stateDir, 'server.pid');
+    }
+    get consoleLog() {
+        return join(this.stateDir, 'console.log');
+    }
+    get logFile() {
+        return join(this.dir, 'logs', 'latest.log');
+    }
+    properties() {
+        return readProperties(this.dir);
+    }
+    get gamePort() {
+        return Number(this.properties().get('server-port') ?? 25565);
+    }
+    /** The world folder named by level-name. A name that leaves the server folder is refused. */
+    get worldDir() {
+        const name = this.properties().get('level-name') || 'world';
+        try {
+            return resolveInside(this.dir, name, { hidden: [STATE_DIR] });
+        }
+        catch (e) {
+            throw new ServerError(`level-name in server.properties must be a folder inside the server folder, not "${name}": ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    pid() {
+        if (!existsSync(this.pidFile))
+            return null;
+        // Written before the computer last started: that process is gone, and the number may now belong to another program.
+        if (statSync(this.pidFile).mtimeMs < Date.now() - uptime() * 1000)
+            return null;
+        const pid = Number(readFileSync(this.pidFile, 'utf8').trim());
+        return Number.isInteger(pid) && pid > 0 && alive(pid) ? pid : null;
+    }
+    async status() {
+        const pid = this.pid();
+        let rcon = false;
+        try {
+            const c = await this.connection();
+            await c.command('list');
+            rcon = true;
+        }
+        catch {
+            rcon = false;
+        }
+        return { running: rcon || pid !== null, pid, rcon };
+    }
+    javaArgs() {
+        const mem = [`-Xmx${this.meta.memoryMb}M`];
+        if (this.meta.launch.type === 'jar')
+            return [...mem, '-jar', this.meta.launch.jar, 'nogui'];
+        const file = process.platform === 'win32' ? 'win_args.txt' : 'unix_args.txt';
+        return [...mem, `@${this.meta.launch.libDir}/${file}`, 'nogui'];
+    }
+    async start(timeoutMs = 300_000) {
+        const began = Date.now();
+        if ((await this.status()).running)
+            throw new ServerError('The server is already running');
+        if (!eulaAccepted(this.dir)) {
+            throw new ServerError(`The Minecraft EULA is not accepted for this server. Show the person ${EULA_URL} and ask; if they accept, call accept_eula.`);
+        }
+        if (!existsSync(this.meta.javaPath))
+            throw new ServerError(`Java not found at ${this.meta.javaPath}. Run plan_setup to see what is needed.`);
+        void this.worldDir; // Minecraft makes the world where level-name says; refused if that leaves the server folder.
+        const fixed = enforceLocked(this.dir, this.meta.rconPort);
+        for (const [what, port] of [['Game', this.gamePort], ['RCON', this.meta.rconPort]]) {
+            if (!(await portFree(port)))
+                throw new ServerError(`${what} port ${port} is in use by another program. Pick another port in server.properties.`);
+        }
+        mkdirSync(this.stateDir, { recursive: true });
+        const out = openSync(this.consoleLog, 'w');
+        this.childExit = null;
+        const child = spawn(this.meta.javaPath, this.javaArgs(), { cwd: this.dir, detached: true, stdio: ['ignore', out, out], windowsHide: true });
+        closeSync(out);
+        child.on('exit', (code) => (this.childExit = code ?? -1));
+        child.unref();
+        if (child.pid)
+            writeFileSync(this.pidFile, String(child.pid));
+        while (Date.now() - began < timeoutMs) {
+            await sleep(1000);
+            if (this.childExit !== null) {
+                throw new ServerError(`The server stopped while starting (exit ${this.childExit}). Last output:\n${this.logs(30).join('\n')}`);
+            }
+            try {
+                const c = await this.connection();
+                await c.command('list');
+                return { seconds: (Date.now() - began) / 1000, fixed };
+            }
+            catch {
+                // not up yet
+            }
+        }
+        throw new ServerError(`The server did not answer on RCON within ${timeoutMs / 1000}s. Check server_logs.`);
+    }
+    async stop(force = false, timeoutMs = 120_000) {
+        const began = Date.now();
+        const pid = this.pid();
+        let asked = false;
+        try {
+            const c = await this.connection();
+            await c.command('stop').catch(() => undefined);
+            asked = true;
+        }
+        catch {
+            asked = false;
+        }
+        this.closeConnections();
+        if (!asked && pid === null)
+            throw new ServerError('The server is not running');
+        if (!asked && !force)
+            throw new ServerError(`The server does not answer on RCON (process ${pid}). Call stop_server with force: true to end the process; unsaved changes may be lost.`);
+        if (!asked && pid !== null) {
+            process.kill(pid);
+            await this.waitGone(pid, 30_000);
+            return { seconds: (Date.now() - began) / 1000, forced: true };
+        }
+        if (pid !== null) {
+            if (!(await this.waitGone(pid, timeoutMs))) {
+                if (!force)
+                    throw new ServerError(`The server is still saving after ${timeoutMs / 1000}s. Wait, or call stop_server with force: true.`);
+                process.kill(pid);
+                await this.waitGone(pid, 30_000);
+                return { seconds: (Date.now() - began) / 1000, forced: true };
+            }
+        }
+        else {
+            while (Date.now() - began < timeoutMs && (await this.rconUp()))
+                await sleep(500);
+        }
+        return { seconds: (Date.now() - began) / 1000, forced: false };
+    }
+    async waitGone(pid, ms) {
+        const until = Date.now() + ms;
+        while (Date.now() < until) {
+            if (!alive(pid) || this.childExit !== null)
+                return true;
+            await sleep(250);
+        }
+        return false;
+    }
+    async rconUp() {
+        try {
+            const c = await Rcon.connect(this.meta.rconPort, this.password(), 2000);
+            c.close();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    password() {
+        const pw = this.properties().get('rcon.password');
+        if (!pw)
+            throw new ServerError('server.properties has no rcon.password; start the server through this tool to set one');
+        return pw;
+    }
+    /** An open RCON connection (the first of the pool). */
+    async connection() {
+        return (await this.connections(1))[0];
+    }
+    /** Up to n open RCON connections, made on demand and reused. */
+    async connections(n) {
+        this.conns = this.conns.filter((c) => c.isOpen);
+        while (this.conns.length < n)
+            this.conns.push(await Rcon.connect(this.meta.rconPort, this.password()));
+        return this.conns.slice(0, n);
+    }
+    closeConnections() {
+        for (const c of this.conns)
+            c.close();
+        this.conns = [];
+    }
+    /** The last lines of the game log, or of the console output if the game log is missing or older. */
+    logs(lines = 100, filter) {
+        const useConsole = !existsSync(this.logFile) || (existsSync(this.consoleLog) && statSync(this.consoleLog).mtimeMs > statSync(this.logFile).mtimeMs + 2000 && this.childExit !== null);
+        let out = tail(useConsole ? this.consoleLog : this.logFile, filter ? 5000 : lines);
+        if (filter)
+            out = out.filter((l) => l.toLowerCase().includes(filter.toLowerCase())).slice(-lines);
+        let pw;
+        try {
+            pw = this.password();
+        }
+        catch {
+            pw = undefined;
+        }
+        return pw ? out.map((l) => l.split(pw).join('<hidden>')) : out;
+    }
+}
+/** Finds how to launch a server folder that was not made by this tool. */
+export function detectLaunch(dir) {
+    for (const artifact of ['neoforge', 'forge']) {
+        const base = join(dir, 'libraries', 'net', 'neoforged', artifact);
+        if (!existsSync(base))
+            continue;
+        const versions = readdirSync(base).filter((v) => existsSync(join(base, v, 'win_args.txt')) || existsSync(join(base, v, 'unix_args.txt')));
+        if (versions.length)
+            return { type: 'argfile', libDir: `libraries/net/neoforged/${artifact}/${versions.sort().pop()}` };
+    }
+    if (existsSync(join(dir, 'server.jar')))
+        return { type: 'jar', jar: 'server.jar' };
+    return null;
+}

package/dist/mc/versions.js

@@ -0,0 +1,108 @@
+import { fetchJson, fetchText } from './download.js';
+// Minecraft versions and where the server files come from: Mojang's version manifest for the
+// game, maven.neoforged.net for NeoForge.
+export const MANIFEST_URL = 'https://piston-meta.mojang.com/mc/game/version_manifest_v2.json';
+export const NEOFORGE_MAVEN = 'https://maven.neoforged.net/releases/net/neoforged';
+export const EULA_URL = 'https://aka.ms/MinecraftEULA';
+export const MIN_VERSION = '1.20.1';
+/** Numeric parts of a release id: 1.21.11 -> [1, 21, 11], 26.1 -> [26, 1, 0]. Null for snapshots. */
+export function versionParts(id) {
+    if (!/^\d+\.\d+(\.\d+)?$/.test(id))
+        return null;
+    const p = id.split('.').map(Number);
+    while (p.length < 3)
+        p.push(0);
+    return p;
+}
+export function compareVersions(a, b) {
+    const pa = versionParts(a), pb = versionParts(b);
+    if (!pa || !pb)
+        throw new Error(`Not a release version: ${!pa ? a : b}`);
+    for (let i = 0; i < 3; i++)
+        if (pa[i] !== pb[i])
+            return pa[i] - pb[i];
+    return 0;
+}
+export function isSupportedVersion(id) {
+    return versionParts(id) !== null && compareVersions(id, MIN_VERSION) >= 0;
+}
+/** The Java each range of releases needs, as Mojang publishes it per version. For doctor, which stays offline. */
+export const JAVA_FOR_MINECRAFT = [
+    { java: 17, minecraft: '1.20.1 to 1.20.4' },
+    { java: 21, minecraft: '1.20.5 to 1.21.11' },
+    { java: 25, minecraft: '26.1 and newer' },
+];
+export function javaNeededFor(minecraft) {
+    if (!isSupportedVersion(minecraft))
+        return null;
+    if (compareVersions(minecraft, '1.20.5') < 0)
+        return 17;
+    return compareVersions(minecraft, '26.1') < 0 ? 21 : 25;
+}
+export async function resolveVersion(requested) {
+    const m = await fetchJson(MANIFEST_URL);
+    const id = requested === 'latest' ? m.latest.release : requested;
+    if (!isSupportedVersion(id))
+        throw new Error(`Minecraft ${id} is not supported. Use a release from ${MIN_VERSION} on (snapshots are not supported).`);
+    const entry = m.versions.find((v) => v.id === id);
+    if (!entry || entry.type !== 'release')
+        throw new Error(`Mojang has no release called ${id}. Latest release: ${m.latest.release}`);
+    return entry;
+}
+export async function serverDownload(entry) {
+    const v = await fetchJson(entry.url, entry.sha1);
+    const s = v.downloads?.server;
+    if (!s)
+        throw new Error(`Mojang publishes no server for ${entry.id}`);
+    return { javaMajor: v.javaVersion?.majorVersion ?? 17, url: s.url, sha1: s.sha1, size: s.size };
+}
+/** NeoForge numbers its builds after the game: 1.21.4 -> 21.4.x, 1.21 -> 21.0.x, 26.1.2 -> 26.1.2.x. 1.20.1 is the older "forge" artifact. */
+export function neoforgePrefix(mc) {
+    const p = versionParts(mc);
+    if (!p)
+        throw new Error(`Not a release version: ${mc}`);
+    if (mc === '1.20.1')
+        return { artifact: 'forge', prefix: '1.20.1-' };
+    if (p[0] === 1)
+        return { artifact: 'neoforge', prefix: `${p[1]}.${p[2]}.` };
+    return { artifact: 'neoforge', prefix: `${p[0]}.${p[1]}.${p[2]}.` };
+}
+export function pickNeoForge(mc, versions) {
+    const { artifact, prefix } = neoforgePrefix(mc);
+    // The version goes into a URL and a folder name, so only plain version characters are used.
+    const usable = versions.filter((v) => v.startsWith(prefix) && /^[\w.-]+$/.test(v) && !/alpha|snapshot|rc/i.test(v));
+    const num = (v) => v.slice(prefix.length).split(/[.-]/).filter((x) => /^\d+$/.test(x)).map(Number);
+    const cmp = (a, b) => {
+        const na = num(a), nb = num(b);
+        for (let i = 0; i < Math.max(na.length, nb.length); i++)
+            if ((na[i] ?? 0) !== (nb[i] ?? 0))
+                return (na[i] ?? 0) - (nb[i] ?? 0);
+        return 0;
+    };
+    const stable = usable.filter((v) => !/beta/i.test(v)).sort(cmp);
+    const beta = usable.filter((v) => /beta/i.test(v)).sort(cmp);
+    const version = stable[stable.length - 1] ?? beta[beta.length - 1];
+    if (!version)
+        return null;
+    return {
+        artifact,
+        version,
+        beta: !stable.length,
+        installerUrl: `${NEOFORGE_MAVEN}/${artifact}/${version}/${artifact}-${version}-installer.jar`,
+    };
+}
+export async function resolveNeoForge(mc) {
+    const { artifact } = neoforgePrefix(mc);
+    const xml = await fetchText(`${NEOFORGE_MAVEN}/${artifact}/maven-metadata.xml`);
+    const versions = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
+    const build = pickNeoForge(mc, versions);
+    if (!build)
+        throw new Error(`NeoForge has no build for Minecraft ${mc} yet`);
+    return build;
+}
+export async function neoforgeSha256(build) {
+    const text = (await fetchText(`${build.installerUrl}.sha256`)).trim().split(/\s+/)[0] ?? '';
+    if (!/^[0-9a-f]{64}$/i.test(text))
+        throw new Error('NeoForge did not publish a usable sha256 for this installer');
+    return text.toLowerCase();
+}