@kzheart_/mc-pilot 0.2.0 → 0.3.0

package/dist/commands/plugin.d.ts

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

package/dist/commands/plugin.js

@@ -0,0 +1,93 @@
+import { Command } from "commander";
+import { PluginCatalogManager } from "../instance/PluginCatalogManager.js";
+import { MctError } from "../util/errors.js";
+import { wrapCommand } from "../util/command.js";
+function parseCommaSeparated(value) {
+    if (!value)
+        return undefined;
+    return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+export function createPluginCommand() {
+    const plugin = new Command("plugin")
+        .description("Manage the plugin center catalog");
+    plugin.addCommand(new Command("list")
+        .description("List plugins in the catalog")
+        .option("--query <query>", "Search by name, id, or description")
+        .action(wrapCommand(async (_context, { options }) => {
+        const manager = new PluginCatalogManager();
+        const plugins = await manager.list(options.query);
+        return { plugins, count: plugins.length };
+    })));
+    plugin.addCommand(new Command("info")
+        .description("Show plugin details")
+        .argument("<id>", "Plugin ID")
+        .action(wrapCommand(async (_context, { args }) => {
+        const manager = new PluginCatalogManager();
+        return manager.get(args[0]);
+    })));
+    plugin.addCommand(new Command("add")
+        .description("Add a plugin JAR to the catalog (id/name auto-derived from filename)")
+        .argument("<jar-path>", "Path to the plugin JAR file")
+        .option("--id <id>", "Override plugin ID")
+        .option("--name <name>", "Override display name")
+        .action(wrapCommand(async (_context, { args, options }) => {
+        const manager = new PluginCatalogManager();
+        return manager.add(args[0], {
+            id: options.id,
+            name: options.name
+        });
+    })));
+    plugin.addCommand(new Command("update")
+        .description("Update plugin metadata")
+        .argument("<id>", "Plugin ID")
+        .option("--name <name>", "Display name")
+        .option("--version <version>", "Version")
+        .option("--description <description>", "Description")
+        .option("--author <author>", "Author")
+        .option("--dependencies <deps>", "Dependency plugin IDs (comma-separated)")
+        .option("--tags <tags>", "Tags (comma-separated)")
+        .action(wrapCommand(async (_context, { args, options }) => {
+        const manager = new PluginCatalogManager();
+        return manager.update(args[0], {
+            name: options.name,
+            version: options.version,
+            description: options.description,
+            author: options.author,
+            dependencies: parseCommaSeparated(options.dependencies),
+            tags: parseCommaSeparated(options.tags)
+        });
+    })));
+    plugin.addCommand(new Command("remove")
+        .description("Remove a plugin from the catalog")
+        .argument("<id>", "Plugin ID")
+        .action(wrapCommand(async (_context, { args }) => {
+        const manager = new PluginCatalogManager();
+        const removed = await manager.remove(args[0]);
+        return { removed: removed.id, name: removed.name };
+    })));
+    plugin.addCommand(new Command("install")
+        .description("Install a plugin (with dependencies) to a server")
+        .argument("<id>", "Plugin ID")
+        .requiredOption("--server <name>", "Target server instance name")
+        .option("--project <name>", "Project name")
+        .action(wrapCommand(async (context, { args, options }) => {
+        const project = options.project ?? context.projectName;
+        if (!project) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project specified. Use --project or run from a project directory." }, 4);
+        }
+        const manager = new PluginCatalogManager();
+        return manager.install(args[0], project, options.server);
+    })));
+    plugin.addCommand(new Command("resolve")
+        .description("Resolve dependency tree for plugins")
+        .argument("<ids...>", "Plugin IDs to resolve")
+        .action(wrapCommand(async (_context, { args }) => {
+        const manager = new PluginCatalogManager();
+        const resolved = await manager.resolve(args);
+        return {
+            order: resolved.map((p) => p.id),
+            plugins: resolved
+        };
+    })));
+    return plugin;
+}

package/dist/index.js

@@ -24,6 +24,7 @@ import { createServerCommand } from "./commands/server.js";
 import { createSignCommand } from "./commands/sign.js";
 import { createStatusCommand } from "./commands/status.js";
 import { createWaitCommand } from "./commands/wait.js";
+import { createPluginCommand } from "./commands/plugin.js";
 import { createInitCommand, createDeployCommand, createUpCommand, createDownCommand, createUseCommand } from "./commands/project.js";
 import { attachGlobalOptions, wrapCommand } from "./util/command.js";
 export function buildProgram() {
@@ -64,6 +65,7 @@ export function buildProgram() {
     // Instance management
     program.addCommand(createServerCommand());
     program.addCommand(createClientCommand());
+    program.addCommand(createPluginCommand());
     // Game interaction commands
     program.addCommand(createChatCommand());
     program.addCommand(createInputCommand());

package/dist/instance/PluginCatalogManager.d.ts

@@ -0,0 +1,18 @@
+import type { PluginCatalog, PluginEntry } from "../util/plugin-types.js";
+export declare class PluginCatalogManager {
+    private pluginsDir;
+    private jarsDir;
+    constructor();
+    loadCatalog(): Promise<PluginCatalog>;
+    private saveCatalog;
+    list(query?: string): Promise<PluginEntry[]>;
+    get(id: string): Promise<PluginEntry>;
+    add(jarPath: string, overrides?: Partial<Omit<PluginEntry, "jarFile" | "addedAt">>): Promise<PluginEntry>;
+    update(id: string, fields: Partial<Omit<PluginEntry, "id" | "jarFile" | "addedAt">>): Promise<PluginEntry>;
+    remove(id: string): Promise<PluginEntry>;
+    resolve(ids: string[]): Promise<PluginEntry[]>;
+    install(id: string, project: string, serverName: string): Promise<{
+        installed: string[];
+        serverPluginsDir: string;
+    }>;
+}

package/dist/instance/PluginCatalogManager.js

@@ -0,0 +1,151 @@
+import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolvePluginsDir, resolvePluginJarsDir, resolveServerInstanceDir } from "../util/paths.js";
+import { MctError } from "../util/errors.js";
+const CATALOG_FILE = "catalog.json";
+export class PluginCatalogManager {
+    pluginsDir;
+    jarsDir;
+    constructor() {
+        this.pluginsDir = resolvePluginsDir();
+        this.jarsDir = resolvePluginJarsDir();
+    }
+    async loadCatalog() {
+        try {
+            const content = await readFile(path.join(this.pluginsDir, CATALOG_FILE), "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return { plugins: [] };
+        }
+    }
+    async saveCatalog(catalog) {
+        await mkdir(this.pluginsDir, { recursive: true });
+        await writeFile(path.join(this.pluginsDir, CATALOG_FILE), JSON.stringify(catalog, null, 2), "utf-8");
+    }
+    async list(query) {
+        const catalog = await this.loadCatalog();
+        if (!query)
+            return catalog.plugins;
+        const q = query.toLowerCase();
+        return catalog.plugins.filter((p) => p.id.toLowerCase().includes(q) ||
+            p.name.toLowerCase().includes(q) ||
+            p.description.toLowerCase().includes(q) ||
+            p.tags.some((t) => t.toLowerCase().includes(q)));
+    }
+    async get(id) {
+        const catalog = await this.loadCatalog();
+        const entry = catalog.plugins.find((p) => p.id === id);
+        if (!entry) {
+            throw new MctError({ code: "PLUGIN_NOT_FOUND", message: `Plugin '${id}' not found in catalog` }, 4);
+        }
+        return entry;
+    }
+    async add(jarPath, overrides) {
+        const catalog = await this.loadCatalog();
+        const resolvedJar = path.resolve(jarPath);
+        const originalName = path.basename(resolvedJar, ".jar");
+        // Derive id from filename if not provided
+        const id = overrides?.id || originalName.toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+        if (catalog.plugins.some((p) => p.id === id)) {
+            throw new MctError({ code: "PLUGIN_EXISTS", message: `Plugin '${id}' already exists in catalog` }, 4);
+        }
+        // Keep original JAR filename
+        const jarFileName = path.basename(resolvedJar);
+        await mkdir(this.jarsDir, { recursive: true });
+        await copyFile(resolvedJar, path.join(this.jarsDir, jarFileName));
+        const entry = {
+            id,
+            name: overrides?.name || originalName,
+            version: overrides?.version || "",
+            description: overrides?.description || "",
+            author: overrides?.author || "",
+            jarFile: jarFileName,
+            dependencies: overrides?.dependencies || [],
+            tags: overrides?.tags || [],
+            addedAt: new Date().toISOString()
+        };
+        catalog.plugins.push(entry);
+        await this.saveCatalog(catalog);
+        return entry;
+    }
+    async update(id, fields) {
+        const catalog = await this.loadCatalog();
+        const entry = catalog.plugins.find((p) => p.id === id);
+        if (!entry) {
+            throw new MctError({ code: "PLUGIN_NOT_FOUND", message: `Plugin '${id}' not found in catalog` }, 4);
+        }
+        if (fields.name !== undefined)
+            entry.name = fields.name;
+        if (fields.version !== undefined)
+            entry.version = fields.version;
+        if (fields.description !== undefined)
+            entry.description = fields.description;
+        if (fields.author !== undefined)
+            entry.author = fields.author;
+        if (fields.dependencies !== undefined)
+            entry.dependencies = fields.dependencies;
+        if (fields.tags !== undefined)
+            entry.tags = fields.tags;
+        await this.saveCatalog(catalog);
+        return entry;
+    }
+    async remove(id) {
+        const catalog = await this.loadCatalog();
+        const index = catalog.plugins.findIndex((p) => p.id === id);
+        if (index === -1) {
+            throw new MctError({ code: "PLUGIN_NOT_FOUND", message: `Plugin '${id}' not found in catalog` }, 4);
+        }
+        const [entry] = catalog.plugins.splice(index, 1);
+        try {
+            await rm(path.join(this.jarsDir, entry.jarFile));
+        }
+        catch {
+            // JAR file may already be deleted
+        }
+        await this.saveCatalog(catalog);
+        return entry;
+    }
+    async resolve(ids) {
+        const catalog = await this.loadCatalog();
+        const byId = new Map(catalog.plugins.map((p) => [p.id, p]));
+        const resolved = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (id) => {
+            if (visited.has(id))
+                return;
+            if (visiting.has(id)) {
+                throw new MctError({ code: "CIRCULAR_DEPENDENCY", message: `Circular dependency detected involving '${id}'` }, 4);
+            }
+            const entry = byId.get(id);
+            if (!entry) {
+                throw new MctError({ code: "MISSING_DEPENDENCY", message: `Missing dependency: '${id}'` }, 4);
+            }
+            visiting.add(id);
+            for (const dep of entry.dependencies) {
+                visit(dep);
+            }
+            visiting.delete(id);
+            visited.add(id);
+            resolved.push(entry);
+        };
+        for (const id of ids) {
+            visit(id);
+        }
+        return resolved;
+    }
+    async install(id, project, serverName) {
+        const toInstall = await this.resolve([id]);
+        const serverPluginsDir = path.join(resolveServerInstanceDir(project, serverName), "plugins");
+        await mkdir(serverPluginsDir, { recursive: true });
+        const installed = [];
+        for (const entry of toInstall) {
+            const src = path.join(this.jarsDir, entry.jarFile);
+            const dest = path.join(serverPluginsDir, entry.jarFile);
+            await copyFile(src, dest);
+            installed.push(entry.id);
+        }
+        return { installed, serverPluginsDir };
+    }
+}

package/dist/util/paths.d.ts

@@ -5,3 +5,5 @@ export declare function resolveProjectsDir(): string;
 export declare function resolveProjectDir(project: string): string;
 export declare function resolveServerInstanceDir(project: string, server: string): string;
 export declare function resolveGlobalStateDir(): string;
+export declare function resolvePluginsDir(): string;
+export declare function resolvePluginJarsDir(): string;

package/dist/util/paths.js

@@ -21,3 +21,9 @@ export function resolveServerInstanceDir(project, server) {
 export function resolveGlobalStateDir() {
     return path.join(resolveMctHome(), "state");
 }
+export function resolvePluginsDir() {
+    return path.join(resolveMctHome(), "plugins");
+}
+export function resolvePluginJarsDir() {
+    return path.join(resolvePluginsDir(), "jars");
+}

package/dist/util/plugin-types.d.ts

@@ -0,0 +1,14 @@
+export interface PluginEntry {
+    id: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    jarFile: string;
+    dependencies: string[];
+    tags: string[];
+    addedAt: string;
+}
+export interface PluginCatalog {
+    plugins: PluginEntry[];
+}

package/dist/util/plugin-types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kzheart_/mc-pilot",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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");
-}