@kzheart_/mc-pilot 0.2.1 → 0.3.1

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/instance/ServerInstanceManager.d.ts

@@ -44,6 +44,7 @@ export declare class ServerInstanceManager {
         startedAt: string;
         logPath: string;
         instanceDir: string;
+        stdinPipe?: string;
         running: boolean;
         stale: boolean;
     } | {
@@ -54,6 +55,7 @@ export declare class ServerInstanceManager {
         startedAt: string;
         logPath: string;
         instanceDir: string;
+        stdinPipe?: string;
         running: boolean;
     }>;
     waitReady(serverName: string, timeoutSeconds: number): Promise<{

package/dist/instance/ServerInstanceManager.js

@@ -1,6 +1,6 @@
-import { copyFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, readdir, readFile, writeFile, unlink } from "node:fs/promises";
 import { mkdirSync, openSync } from "node:fs";
-import { spawn } from "node:child_process";
+import { spawn, execSync } from "node:child_process";
 import path from "node:path";
 import { resolveProjectDir, resolveServerInstanceDir } from "../util/paths.js";
 import { MctError } from "../util/errors.js";
@@ -57,17 +57,34 @@ export class ServerInstanceManager {
             await writeFile(path.join(instanceDir, "eula.txt"), "eula=true\n", "utf8");
         }
         const logsDir = path.join(this.globalState.getRootDir(), "logs");
+        const stateDir = path.join(this.globalState.getRootDir(), "state");
         mkdirSync(logsDir, { recursive: true });
+        mkdirSync(stateDir, { recursive: true });
         const logPath = path.join(logsDir, `server-${this.project}-${serverName}.log`);
         const stdout = openSync(logPath, "a");
         const jvmArgs = options.jvmArgs ?? meta.jvmArgs;
-        const child = spawn("java", [...jvmArgs, "-jar", jarFile, "nogui"], {
+        // Create a named pipe (FIFO) for stdin so external tools (GUI) can send commands
+        const stdinPipe = path.join(stateDir, `stdin-${this.project}-${serverName}.fifo`);
+        try {
+            await unlink(stdinPipe);
+        }
+        catch { /* ignore */ }
+        execSync(`mkfifo "${stdinPipe}"`);
+        // Use bash wrapper: hold FIFO write end open (fd 3) to prevent EOF,
+        // then exec java with stdin reading from the FIFO
+        const child = spawn("bash", [
+            "-c",
+            'exec 3>"$MCT_STDIN_PIPE"; exec java "$@" <"$MCT_STDIN_PIPE"',
+            "mct-server",
+            ...jvmArgs, "-jar", jarFile, "nogui"
+        ], {
             cwd: instanceDir,
             detached: true,
             stdio: ["ignore", stdout, stdout],
             env: {
                 ...process.env,
-                MCT_SERVER_PORT: String(meta.port)
+                MCT_SERVER_PORT: String(meta.port),
+                MCT_STDIN_PIPE: stdinPipe
             }
         });
         child.unref();
@@ -78,7 +95,8 @@ export class ServerInstanceManager {
             port: meta.port,
             startedAt: new Date().toISOString(),
             logPath,
-            instanceDir
+            instanceDir,
+            stdinPipe
         };
         state.servers[stateKey] = entry;
         await this.globalState.writeServerState(state);
@@ -94,6 +112,13 @@ export class ServerInstanceManager {
         if (isProcessRunning(entry.pid)) {
             killProcessTree(entry.pid);
         }
+        // Clean up FIFO
+        if (entry.stdinPipe) {
+            try {
+                await unlink(entry.stdinPipe);
+            }
+            catch { /* ignore */ }
+        }
         delete state.servers[stateKey];
         await this.globalState.writeServerState(state);
         return { running: false, stopped: true, pid: entry.pid };

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

@@ -28,6 +28,7 @@ export interface ServerRuntimeEntry {
     startedAt: string;
     logPath: string;
     instanceDir: string;
+    stdinPipe?: string;
 }
 export interface ClientRuntimeEntry {
     pid: number;

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.1",
+  "version": "0.3.1",
   "description": "Minecraft plugin/mod automated testing CLI – control a real Minecraft client to simulate player actions",
   "type": "module",
   "bin": {