@kzheart_/mc-pilot 0.1.0

package/bin/mct

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/index.js");

package/data/variants.json

@@ -0,0 +1,139 @@
+{
+  "defaultVariant": "1.20.4-fabric",
+  "buildSystem": "multi-module",
+  "versions": ["1.18.2", "1.20.1", "1.20.2", "1.20.4", "1.21.1", "1.21.4"],
+  "variants": [
+    {
+      "id": "1.18.2-fabric",
+      "minecraftVersion": "1.18.2",
+      "loader": "fabric",
+      "support": "ready",
+      "validation": "verified",
+      "modVersion": "0.1.0",
+      "fabricLoaderVersion": "0.16.10",
+      "yarnMappings": "1.18.2+build.4",
+      "javaVersion": 17,
+      "gradleModule": "version-1.18.2"
+    },
+    {
+      "id": "1.20.1-fabric",
+      "minecraftVersion": "1.20.1",
+      "loader": "fabric",
+      "support": "ready",
+      "validation": "verified",
+      "modVersion": "0.1.0",
+      "fabricLoaderVersion": "0.16.10",
+      "yarnMappings": "1.20.1+build.10",
+      "javaVersion": 17,
+      "gradleModule": "version-1.20.1"
+    },
+    {
+      "id": "1.20.1-forge",
+      "minecraftVersion": "1.20.1",
+      "loader": "forge",
+      "support": "planned",
+      "validation": "planned",
+      "modVersion": "0.1.0",
+      "forgeVersion": "47.3.0",
+      "javaVersion": 17
+    },
+    {
+      "id": "1.20.2-fabric",
+      "minecraftVersion": "1.20.2",
+      "loader": "fabric",
+      "support": "ready",
+      "validation": "verified",
+      "modVersion": "0.1.0",
+      "fabricLoaderVersion": "0.16.10",
+      "yarnMappings": "1.20.2+build.4",
+      "javaVersion": 17,
+      "gradleModule": "version-1.20.2"
+    },
+    {
+      "id": "1.20.2-forge",
+      "minecraftVersion": "1.20.2",
+      "loader": "forge",
+      "support": "planned",
+      "validation": "planned",
+      "modVersion": "0.1.0",
+      "forgeVersion": "48.1.0",
+      "javaVersion": 17
+    },
+    {
+      "id": "1.20.4-fabric",
+      "minecraftVersion": "1.20.4",
+      "loader": "fabric",
+      "support": "ready",
+      "validation": "verified",
+      "modVersion": "0.1.0",
+      "fabricLoaderVersion": "0.16.10",
+      "yarnMappings": "1.20.4+build.3",
+      "javaVersion": 17,
+      "gradleModule": "version-1.20.4"
+    },
+    {
+      "id": "1.20.4-forge",
+      "minecraftVersion": "1.20.4",
+      "loader": "forge",
+      "support": "planned",
+      "validation": "planned",
+      "modVersion": "0.1.0",
+      "forgeVersion": "49.0.49",
+      "javaVersion": 17
+    },
+    {
+      "id": "1.20.4-neoforge",
+      "minecraftVersion": "1.20.4",
+      "loader": "neoforge",
+      "support": "planned",
+      "validation": "planned",
+      "modVersion": "0.1.0",
+      "neoforgeVersion": "20.4.237",
+      "javaVersion": 17
+    },
+    {
+      "id": "1.21.1-fabric",
+      "minecraftVersion": "1.21.1",
+      "loader": "fabric",
+      "support": "ready",
+      "validation": "verified",
+      "modVersion": "0.1.0",
+      "fabricLoaderVersion": "0.16.10",
+      "yarnMappings": "1.21.1+build.3",
+      "javaVersion": 21,
+      "gradleModule": "version-1.21.1"
+    },
+    {
+      "id": "1.21.1-neoforge",
+      "minecraftVersion": "1.21.1",
+      "loader": "neoforge",
+      "support": "planned",
+      "validation": "planned",
+      "modVersion": "0.1.0",
+      "neoforgeVersion": "21.1.77",
+      "javaVersion": 21
+    },
+    {
+      "id": "1.21.4-fabric",
+      "minecraftVersion": "1.21.4",
+      "loader": "fabric",
+      "support": "ready",
+      "validation": "verified",
+      "modVersion": "0.1.0",
+      "fabricLoaderVersion": "0.16.10",
+      "yarnMappings": "1.21.4+build.1",
+      "javaVersion": 21,
+      "gradleModule": "version-1.21.4"
+    },
+    {
+      "id": "1.21.4-neoforge",
+      "minecraftVersion": "1.21.4",
+      "loader": "neoforge",
+      "support": "planned",
+      "validation": "planned",
+      "modVersion": "0.1.0",
+      "neoforgeVersion": "21.4.75",
+      "javaVersion": 21
+    }
+  ]
+}

package/dist/client/ClientManager.d.ts

@@ -0,0 +1,82 @@
+import type { CommandContext } from "../util/context.js";
+export interface ClientRuntimeState {
+    name: string;
+    version?: string;
+    account?: string;
+    server?: string;
+    wsPort: number;
+    headless: boolean;
+    pid: number;
+    startedAt: string;
+    logPath: string;
+}
+export interface LaunchClientOptions {
+    name: string;
+    version?: string;
+    account?: string;
+    server?: string;
+    wsPort?: number;
+    headless?: boolean;
+}
+export declare class ClientManager {
+    private readonly context;
+    constructor(context: CommandContext);
+    launch(options: LaunchClientOptions): Promise<ClientRuntimeState>;
+    stop(name: string): Promise<{
+        stopped: boolean;
+        name: string;
+        pid?: undefined;
+    } | {
+        stopped: boolean;
+        name: string;
+        pid: number;
+    }>;
+    list(): Promise<{
+        defaultClient: string | undefined;
+        clients: ({
+            running: boolean;
+            detached: boolean;
+            name: string;
+            version?: string;
+            account?: string;
+            server?: string;
+            wsPort: number;
+            headless: boolean;
+            pid: number;
+            startedAt: string;
+            logPath: string;
+        } | {
+            running: boolean;
+            stale: boolean;
+            name: string;
+            version?: string;
+            account?: string;
+            server?: string;
+            wsPort: number;
+            headless: boolean;
+            pid: number;
+            startedAt: string;
+            logPath: string;
+        } | {
+            running: boolean;
+            name: string;
+            version?: string;
+            account?: string;
+            server?: string;
+            wsPort: number;
+            headless: boolean;
+            pid: number;
+            startedAt: string;
+            logPath: string;
+        })[];
+    }>;
+    waitReady(name: string, timeoutSeconds: number): Promise<{
+        connected: boolean;
+        url: string;
+    }>;
+    getClient(name?: string): Promise<ClientRuntimeState>;
+    getWsUrl(wsPort: number): string;
+    private getSnapshot;
+    private writeSnapshot;
+    private isWsReachable;
+}

package/dist/client/ClientManager.js

@@ -0,0 +1,213 @@
+import { mkdirSync, openSync } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { MctError } from "../util/errors.js";
+import { getListeningPids, isProcessRunning, killProcessTree } from "../util/process.js";
+import { WebSocketClient } from "./WebSocketClient.js";
+const CLIENT_STATE_FILE = "clients.json";
+function getDefaultSnapshot() {
+    return {
+        clients: {}
+    };
+}
+export class ClientManager {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async launch(options) {
+        const snapshot = await this.getSnapshot();
+        const existing = snapshot.clients[options.name];
+        if (existing && isProcessRunning(existing.pid)) {
+            throw new MctError({
+                code: "CLIENT_ALREADY_RUNNING",
+                message: `Client ${options.name} is already running`,
+                details: existing
+            }, 3);
+        }
+        const configured = this.context.config.clients[options.name] ?? {};
+        const wsPort = options.wsPort ?? configured.wsPort;
+        if (!wsPort) {
+            throw new MctError({
+                code: "INVALID_PARAMS",
+                message: `Client ${options.name} requires wsPort`
+            }, 4);
+        }
+        const listeningPids = getListeningPids(wsPort);
+        for (const pid of listeningPids) {
+            killProcessTree(pid);
+        }
+        if (listeningPids.length > 0) {
+            const deadline = Date.now() + 10_000;
+            while (Date.now() < deadline) {
+                if (getListeningPids(wsPort).length === 0) {
+                    break;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+        }
+        const launchCommand = configured.launchCommand;
+        if (!launchCommand || launchCommand.length === 0) {
+            throw new MctError({
+                code: "INVALID_PARAMS",
+                message: `Client ${options.name} requires launchCommand in config`
+            }, 4);
+        }
+        const cwd = configured.workingDir
+            ? path.resolve(this.context.cwd, configured.workingDir)
+            : this.context.cwd;
+        mkdirSync(path.join(this.context.state.getRootDir(), "logs"), { recursive: true });
+        const logPath = path.join(this.context.state.getRootDir(), "logs", `client-${options.name}.log`);
+        const stdout = openSync(logPath, "a");
+        const child = spawn(launchCommand[0], launchCommand.slice(1), {
+            cwd,
+            detached: true,
+            stdio: ["ignore", stdout, stdout],
+            env: {
+                ...process.env,
+                ...configured.env,
+                MCT_CLIENT_NAME: options.name,
+                MCT_CLIENT_VERSION: options.version ?? configured.version ?? "",
+                MCT_CLIENT_ACCOUNT: options.account ?? configured.account ?? "",
+                MCT_CLIENT_SERVER: options.server ?? configured.server ?? "",
+                MCT_CLIENT_WS_PORT: String(wsPort),
+                MCT_CLIENT_HEADLESS: String(options.headless ?? configured.headless ?? false)
+            }
+        });
+        child.unref();
+        const clientState = {
+            name: options.name,
+            version: options.version ?? configured.version,
+            account: options.account ?? configured.account,
+            server: options.server ?? configured.server,
+            wsPort,
+            headless: options.headless ?? configured.headless ?? false,
+            pid: child.pid ?? 0,
+            startedAt: new Date().toISOString(),
+            logPath
+        };
+        snapshot.defaultClient ??= options.name;
+        snapshot.clients[options.name] = clientState;
+        await this.writeSnapshot(snapshot);
+        return clientState;
+    }
+    async stop(name) {
+        const snapshot = await this.getSnapshot();
+        const client = snapshot.clients[name];
+        if (!client) {
+            return {
+                stopped: false,
+                name
+            };
+        }
+        if (isProcessRunning(client.pid)) {
+            killProcessTree(client.pid);
+        }
+        for (const pid of getListeningPids(client.wsPort)) {
+            if (pid !== client.pid) {
+                killProcessTree(pid);
+            }
+        }
+        delete snapshot.clients[name];
+        if (snapshot.defaultClient === name) {
+            snapshot.defaultClient = Object.keys(snapshot.clients)[0];
+        }
+        await this.writeSnapshot(snapshot);
+        return {
+            stopped: true,
+            name,
+            pid: client.pid
+        };
+    }
+    async list() {
+        const snapshot = await this.getSnapshot();
+        const clients = await Promise.all(Object.values(snapshot.clients).map(async (client) => {
+            const running = isProcessRunning(client.pid);
+            if (!running) {
+                const wsReachable = await this.isWsReachable(client.wsPort, 1);
+                if (wsReachable) {
+                    return {
+                        ...client,
+                        running: true,
+                        detached: true
+                    };
+                }
+                return {
+                    ...client,
+                    running: false,
+                    stale: true
+                };
+            }
+            return {
+                ...client,
+                running: true
+            };
+        }));
+        return {
+            defaultClient: snapshot.defaultClient,
+            clients
+        };
+    }
+    async waitReady(name, timeoutSeconds) {
+        const client = await this.getClient(name);
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        while (Date.now() < deadline) {
+            try {
+                const ws = new WebSocketClient(this.getWsUrl(client.wsPort));
+                return await ws.ping(1);
+            }
+            catch {
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 500);
+                });
+            }
+        }
+        throw new MctError({
+            code: "TIMEOUT",
+            message: `Timed out waiting for client ${name} to open WebSocket on ${this.getWsUrl(client.wsPort)}`
+        }, 2);
+    }
+    async getClient(name) {
+        const snapshot = await this.getSnapshot();
+        const resolvedName = name ?? snapshot.defaultClient;
+        if (!resolvedName) {
+            throw new MctError({
+                code: "CLIENT_NOT_FOUND",
+                message: "No client is configured or running"
+            }, 3);
+        }
+        const client = snapshot.clients[resolvedName];
+        if (!client) {
+            throw new MctError({
+                code: "CLIENT_NOT_FOUND",
+                message: `Client ${resolvedName} was not found`
+            }, 3);
+        }
+        if (!isProcessRunning(client.pid) && !(await this.isWsReachable(client.wsPort, 1))) {
+            throw new MctError({
+                code: "CLIENT_NOT_RUNNING",
+                message: `Client ${resolvedName} is not running`
+            }, 3);
+        }
+        return client;
+    }
+    getWsUrl(wsPort) {
+        return `ws://127.0.0.1:${wsPort}`;
+    }
+    async getSnapshot() {
+        return this.context.state.readJson(CLIENT_STATE_FILE, getDefaultSnapshot());
+    }
+    async writeSnapshot(snapshot) {
+        await this.context.state.writeJson(CLIENT_STATE_FILE, snapshot);
+    }
+    async isWsReachable(wsPort, timeoutSeconds) {
+        try {
+            const ws = new WebSocketClient(this.getWsUrl(wsPort));
+            await ws.ping(timeoutSeconds);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/client/WebSocketClient.d.ts

@@ -0,0 +1,15 @@
+export interface WsRequest {
+    id: string;
+    action: string;
+    params?: Record<string, unknown>;
+}
+export declare class WebSocketClient {
+    private readonly url;
+    constructor(url: string);
+    send(action: string, params?: Record<string, unknown>, timeoutSeconds?: number): Promise<unknown>;
+    ping(timeoutSeconds?: number): Promise<{
+        connected: boolean;
+        url: string;
+    }>;
+    private connect;
+}

package/dist/client/WebSocketClient.js

@@ -0,0 +1,76 @@
+import { randomUUID } from "node:crypto";
+import WebSocket from "ws";
+import { MctError } from "../util/errors.js";
+export class WebSocketClient {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    async send(action, params = {}, timeoutSeconds = 10) {
+        const request = {
+            id: randomUUID(),
+            action,
+            params
+        };
+        const socket = await this.connect(timeoutSeconds);
+        try {
+            const response = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new MctError({
+                        code: "TIMEOUT",
+                        message: `Timed out waiting for response from ${this.url}`
+                    }, 2));
+                }, timeoutSeconds * 1000);
+                socket.once("message", (data) => {
+                    clearTimeout(timeout);
+                    try {
+                        resolve(JSON.parse(data.toString()));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                socket.once("error", (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+                socket.send(JSON.stringify(request));
+            });
+            return response;
+        }
+        finally {
+            socket.close();
+        }
+    }
+    async ping(timeoutSeconds = 10) {
+        const socket = await this.connect(timeoutSeconds);
+        socket.close();
+        return {
+            connected: true,
+            url: this.url
+        };
+    }
+    async connect(timeoutSeconds) {
+        return new Promise((resolve, reject) => {
+            const socket = new WebSocket(this.url);
+            const timeout = setTimeout(() => {
+                socket.terminate();
+                reject(new MctError({
+                    code: "TIMEOUT",
+                    message: `Timed out connecting to ${this.url}`
+                }, 2));
+            }, timeoutSeconds * 1000);
+            socket.once("open", () => {
+                clearTimeout(timeout);
+                resolve(socket);
+            });
+            socket.once("error", () => {
+                clearTimeout(timeout);
+                reject(new MctError({
+                    code: "CONNECTION_FAILED",
+                    message: `Unable to connect to ${this.url}`
+                }, 1));
+            });
+        });
+    }
+}

package/dist/commands/block.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createBlockCommand(): Command;

package/dist/commands/block.js

@@ -0,0 +1,52 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createBlockCommand() {
+    const command = new Command("block").description("Block interaction");
+    command
+        .command("break")
+        .description("Break a block")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .action(createRequestAction("block.break", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2])
+    })));
+    command
+        .command("place")
+        .description("Place the held block at the given position")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .requiredOption("--face <face>", "Block face to place against: up|down|north|south|east|west")
+        .action(createRequestAction("block.place", ({ args, options }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2]),
+        face: options.face
+    })));
+    command
+        .command("interact")
+        .description("Right-click a block (e.g. open chest, crafting table, door)")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .action(createRequestAction("block.interact", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2])
+    })));
+    command
+        .command("get")
+        .description("Query block info at coordinates")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .action(createRequestAction("block.get", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2])
+    })));
+    return command;
+}

package/dist/commands/book.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createBookCommand(): Command;

package/dist/commands/book.js

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createBookCommand() {
+    const command = new Command("book").description("Book and quill operations (must hold a writable book)");
+    command.command("read").description("Read book contents").action(createRequestAction("book.read", () => ({})));
+    command
+        .command("write")
+        .description("Write book pages")
+        .requiredOption("--pages <pages...>", "Page contents, e.g. --pages \"Page 1 text\" \"Page 2 text\"")
+        .action(createRequestAction("book.write", ({ options }) => ({ pages: options.pages })));
+    command
+        .command("sign")
+        .description("Sign and close the book")
+        .requiredOption("--title <title>", "Book title")
+        .requiredOption("--author <author>", "Author name")
+        .action(createRequestAction("book.sign", ({ options }) => ({
+        title: options.title,
+        author: options.author
+    })));
+    return command;
+}

package/dist/commands/channel.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createChannelCommand(): Command;

package/dist/commands/channel.js

@@ -0,0 +1,24 @@
+import { Command } from "commander";
+import { createRequestAction, parseJson, withTransportTimeoutBuffer } from "./request-helpers.js";
+export function createChannelCommand() {
+    const command = new Command("channel").description("Plugin Channel");
+    command
+        .command("send")
+        .description("发送频道消息")
+        .argument("<channel>", "频道名称")
+        .requiredOption("--data <json>", "JSON 数据")
+        .action(createRequestAction("channel.send", ({ args, options }) => ({
+        channel: args[0],
+        data: parseJson(String(options.data), "data")
+    })));
+    command
+        .command("listen")
+        .description("监听频道消息")
+        .argument("<channel>", "频道名称")
+        .option("--timeout <seconds>", "等待超时秒数", Number)
+        .action(createRequestAction("channel.listen", ({ args, options }) => ({
+        channel: args[0],
+        timeout: options.timeout
+    }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.config.timeout.default)));
+    return command;
+}

package/dist/commands/chat.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createChatCommand(): Command;

package/dist/commands/chat.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { createRequestAction, withTransportTimeoutBuffer } from "./request-helpers.js";
+export function createChatCommand() {
+    const command = new Command("chat").description("Chat and server commands");
+    command
+        .command("send")
+        .description("Send a chat message")
+        .argument("<message>", "Message text")
+        .action(createRequestAction("chat.send", ({ args }) => ({ message: args[0] })));
+    command
+        .command("command")
+        .description("Execute a server command (no / prefix needed)")
+        .argument("<command>", "Command text, e.g. \"gamemode creative\"")
+        .action(createRequestAction("chat.command", ({ args }) => ({ command: args[0] })));
+    command
+        .command("history")
+        .description("Get chat history")
+        .option("--last <count>", "Number of recent messages (default: 10)", Number)
+        .action(createRequestAction("chat.history", ({ options }) => ({ last: options.last ?? 10 })));
+    command
+        .command("wait")
+        .description("Wait for a chat message matching a pattern")
+        .requiredOption("--match <pattern>", "Substring match by default; prefix with / for regex (e.g. /player\\d+/)")
+        .option("--timeout <seconds>", "Timeout in seconds", Number)
+        .action(createRequestAction("chat.wait", ({ options }) => ({ match: options.match, timeout: options.timeout }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.config.timeout.default)));
+    command
+        .command("last")
+        .description("Get the last chat message")
+        .action(createRequestAction("chat.last", () => ({})));
+    return command;
+}

package/dist/commands/client.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createClientCommand(): Command;