@kzheart_/mc-pilot 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kzheart_/mc-pilot",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Minecraft plugin/mod automated testing CLI – control a real Minecraft client to simulate player actions",
   "type": "module",
   "bin": {

package/dist/client/ClientManager.d.ts

@@ -1,82 +0,0 @@
-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

@@ -1,221 +0,0 @@
-import { mkdirSync, openSync } from "node:fs";
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { MctError } from "../util/errors.js";
-import { getListeningPids, isProcessRunning, killProcessTree } from "../util/process.js";
-import { WebSocketClient } from "./WebSocketClient.js";
-function getLaunchScriptPath() {
-    const thisFile = fileURLToPath(import.meta.url);
-    // dist/client/ClientManager.js -> scripts/launch-fabric-client.mjs
-    return path.resolve(path.dirname(thisFile), "..", "..", "scripts", "launch-fabric-client.mjs");
-}
-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.launchArgs
-            ? [process.execPath, getLaunchScriptPath(), ...configured.launchArgs]
-            : configured.launchCommand;
-        if (!launchCommand || launchCommand.length === 0) {
-            throw new MctError({
-                code: "INVALID_PARAMS",
-                message: `Client ${options.name} requires launchArgs (or 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/commands/channel.d.ts

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

package/dist/commands/channel.js

@@ -1,24 +0,0 @@
-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/effects.d.ts

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

package/dist/commands/effects.js

@@ -1,16 +0,0 @@
-import { Command } from "commander";
-import { createRequestAction } from "./request-helpers.js";
-export function createEffectsCommand() {
-    const command = new Command("effects").description("音效与粒子事件");
-    command
-        .command("sounds")
-        .description("获取音效事件")
-        .option("--last <count>", "最近条数", Number)
-        .action(createRequestAction("effects.sounds", ({ options }) => ({ last: options.last ?? 10 })));
-    command
-        .command("particles")
-        .description("获取粒子事件")
-        .option("--last <count>", "最近条数", Number)
-        .action(createRequestAction("effects.particles", ({ options }) => ({ last: options.last ?? 10 })));
-    return command;
-}

package/dist/server/ServerManager.d.ts

@@ -1,63 +0,0 @@
-import type { CommandContext } from "../util/context.js";
-export interface ServerRuntimeState {
-    pid: number;
-    jar: string;
-    dir: string;
-    port: number;
-    startedAt: string;
-    logPath: string;
-}
-export interface StartServerOptions {
-    jar?: string;
-    dir?: string;
-    port?: number;
-    eula?: boolean;
-}
-export declare class ServerManager {
-    private readonly context;
-    constructor(context: CommandContext);
-    start(options: StartServerOptions): Promise<{
-        pid: number;
-        jar: string;
-        dir: string;
-        port: number;
-        startedAt: string;
-        logPath: string;
-        running: boolean;
-    }>;
-    stop(): Promise<{
-        running: boolean;
-        stopped: boolean;
-        pid?: undefined;
-    } | {
-        running: boolean;
-        stopped: boolean;
-        pid: number;
-    }>;
-    status(): Promise<{
-        running: boolean;
-    } | {
-        pid: number;
-        jar: string;
-        dir: string;
-        port: number;
-        startedAt: string;
-        logPath: string;
-        running: boolean;
-        stale: boolean;
-    } | {
-        pid: number;
-        jar: string;
-        dir: string;
-        port: number;
-        startedAt: string;
-        logPath: string;
-        running: boolean;
-    }>;
-    waitReady(timeoutSeconds: number): Promise<{
-        reachable: boolean;
-        host: string;
-        port: number;
-    }>;
-    getState(): Promise<ServerRuntimeState | null>;
-}

package/dist/server/ServerManager.js

@@ -1,114 +0,0 @@
-import { mkdirSync, openSync, writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { MctError } from "../util/errors.js";
-import { waitForTcpPort } from "../util/net.js";
-import { isProcessRunning, killProcessTree } from "../util/process.js";
-const SERVER_STATE_FILE = "server.json";
-export class ServerManager {
-    context;
-    constructor(context) {
-        this.context = context;
-    }
-    async start(options) {
-        const existing = await this.getState();
-        if (existing && isProcessRunning(existing.pid)) {
-            throw new MctError({
-                code: "SERVER_ALREADY_RUNNING",
-                message: "Server is already running",
-                details: existing
-            }, 5);
-        }
-        const jar = options.jar ?? this.context.config.server.jar;
-        if (!jar) {
-            throw new MctError({
-                code: "INVALID_PARAMS",
-                message: "Server jar is required"
-            }, 4);
-        }
-        const dir = path.resolve(this.context.cwd, options.dir ?? this.context.config.server.dir);
-        const port = options.port ?? this.context.config.server.port;
-        mkdirSync(dir, { recursive: true });
-        mkdirSync(path.join(this.context.state.getRootDir(), "logs"), { recursive: true });
-        if (options.eula) {
-            writeFileSync(path.join(dir, "eula.txt"), "eula=true\n", "utf8");
-        }
-        const logPath = path.join(this.context.state.getRootDir(), "logs", "paper-server.log");
-        const stdout = openSync(logPath, "a");
-        const child = spawn("java", [...this.context.config.server.jvmArgs, "-jar", path.resolve(this.context.cwd, jar), "nogui"], {
-            cwd: dir,
-            detached: true,
-            stdio: ["ignore", stdout, stdout],
-            env: {
-                ...process.env,
-                MCT_SERVER_PORT: String(port)
-            }
-        });
-        child.unref();
-        const state = {
-            pid: child.pid ?? 0,
-            jar: path.resolve(this.context.cwd, jar),
-            dir,
-            port,
-            startedAt: new Date().toISOString(),
-            logPath
-        };
-        await this.context.state.writeJson(SERVER_STATE_FILE, state);
-        return {
-            running: true,
-            ...state
-        };
-    }
-    async stop() {
-        const state = await this.getState();
-        if (!state) {
-            return {
-                running: false,
-                stopped: false
-            };
-        }
-        if (isProcessRunning(state.pid)) {
-            killProcessTree(state.pid);
-        }
-        await this.context.state.remove(SERVER_STATE_FILE);
-        return {
-            running: false,
-            stopped: true,
-            pid: state.pid
-        };
-    }
-    async status() {
-        const state = await this.getState();
-        if (!state) {
-            return {
-                running: false
-            };
-        }
-        const running = isProcessRunning(state.pid);
-        if (!running) {
-            await this.context.state.remove(SERVER_STATE_FILE);
-            return {
-                running: false,
-                stale: true,
-                ...state
-            };
-        }
-        return {
-            running: true,
-            ...state
-        };
-    }
-    async waitReady(timeoutSeconds) {
-        const state = await this.getState();
-        if (!state) {
-            throw new MctError({
-                code: "SERVER_NOT_RUNNING",
-                message: "Server is not running"
-            }, 5);
-        }
-        return waitForTcpPort("127.0.0.1", state.port, timeoutSeconds);
-    }
-    async getState() {
-        return this.context.state.readJson(SERVER_STATE_FILE, null);
-    }
-}

package/dist/util/config.d.ts

@@ -1,31 +0,0 @@
-export declare const DEFAULT_WS_PORT_BASE = 25580;
-export interface MctConfig {
-    server: {
-        jar?: string;
-        dir: string;
-        port: number;
-        jvmArgs: string[];
-    };
-    clients: Record<string, {
-        version?: string;
-        account?: string;
-        wsPort?: number;
-        server?: string;
-        headless?: boolean;
-        launchCommand?: string[];
-        launchArgs?: string[];
-        workingDir?: string;
-        env?: Record<string, string>;
-    }>;
-    screenshot: {
-        outputDir: string;
-    };
-    timeout: {
-        serverReady: number;
-        clientReady: number;
-        default: number;
-    };
-}
-export declare function resolveConfigPath(configPath: string | undefined, cwd: string): string;
-export declare function loadConfig(configPath: string | undefined, cwd: string): Promise<MctConfig>;
-export declare function writeConfig(configPath: string | undefined, cwd: string, config: MctConfig): Promise<void>;

package/dist/util/config.js

@@ -1,59 +0,0 @@
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-export const DEFAULT_WS_PORT_BASE = 25580;
-function createDefaultConfig() {
-    return {
-        server: {
-            dir: "./server",
-            port: 25565,
-            jvmArgs: []
-        },
-        clients: {},
-        screenshot: {
-            outputDir: "./screenshots"
-        },
-        timeout: {
-            serverReady: 120,
-            clientReady: 60,
-            default: 10
-        }
-    };
-}
-export function resolveConfigPath(configPath, cwd) {
-    if (!configPath) {
-        return path.join(cwd, "mct.config.json");
-    }
-    return path.isAbsolute(configPath) ? configPath : path.resolve(cwd, configPath);
-}
-export async function loadConfig(configPath, cwd) {
-    const resolvedPath = resolveConfigPath(configPath, cwd);
-    const defaultConfig = createDefaultConfig();
-    try {
-        await access(resolvedPath);
-    }
-    catch {
-        return defaultConfig;
-    }
-    const raw = await readFile(resolvedPath, "utf8");
-    const parsed = JSON.parse(raw);
-    return {
-        server: {
-            ...defaultConfig.server,
-            ...parsed.server
-        },
-        clients: parsed.clients ?? defaultConfig.clients,
-        screenshot: {
-            ...defaultConfig.screenshot,
-            ...parsed.screenshot
-        },
-        timeout: {
-            ...defaultConfig.timeout,
-            ...parsed.timeout
-        }
-    };
-}
-export async function writeConfig(configPath, cwd, config) {
-    const resolvedPath = resolveConfigPath(configPath, cwd);
-    await mkdir(path.dirname(resolvedPath), { recursive: true });
-    await writeFile(resolvedPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-}