@kzheart_/mc-pilot 0.1.7 → 0.2.0

package/dist/commands/chat.js

@@ -22,7 +22,7 @@ export function createChatCommand() {
         .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)));
+        .action(createRequestAction("chat.wait", ({ options }) => ({ match: options.match, timeout: options.timeout }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.timeout("default"))));
     command
         .command("last")
         .description("Get the last chat message")

package/dist/commands/client.js

@@ -1,11 +1,19 @@
 import { Command } from "commander";
-import { ClientManager } from "../client/ClientManager.js";
-import { downloadClientMod } from "../download/client/ClientDownloader.js";
 import { buildClientSearchResults } from "../download/SearchCommand.js";
+import { ClientInstanceManager } from "../instance/ClientInstanceManager.js";
+import { MctError } from "../util/errors.js";
 import { createRequestAction } from "./request-helpers.js";
 import { wrapCommand } from "../util/command.js";
+import { CacheManager } from "../download/CacheManager.js";
+import { findVariantByVersionAndLoader, getModArtifactFileName, loadModVariantCatalog } from "../download/ModVariantCatalog.js";
+import { detectJava } from "../download/JavaDetector.js";
+import { prepareManagedFabricRuntime } from "../download/client/FabricRuntimeDownloader.js";
+import { copyFileIfMissing, downloadFile } from "../download/DownloadUtils.js";
+import { resolveClientInstanceDir } from "../util/paths.js";
+import { access, mkdir } from "node:fs/promises";
+import path from "node:path";
 export function createClientCommand() {
-    const command = new Command("client").description("Manage Minecraft client");
+    const command = new Command("client").description("Manage Minecraft client instances");
     command
         .command("search")
         .description("Search available client version and loader combinations")
@@ -20,66 +28,147 @@ export function createClientCommand() {
         };
     }));
     command
-        .command("download")
-        .description("Download client mod and update config")
-        .option("--loader <loader>", "Client loader: fabric|forge|neoforge (default: fabric)")
-        .option("--version <version>", "Minecraft version (default: 1.20.4)")
-        .option("--dir <path>", "Mod download directory")
-        .option("--name <name>", "Client config name (default: \"default\"); use this name with \"client launch\"")
-        .option("--ws-port <port>", "WebSocket port for CLI-to-mod communication (default: 25560)", Number)
-        .option("--server <address>", "Default server address (e.g. localhost:25565)")
-        .option("--instance-dir <path>", "Client instance directory")
-        .option("--meta-dir <path>", "Runtime metadata directory")
-        .option("--libraries-dir <path>", "Runtime libraries directory")
-        .option("--assets-dir <path>", "Runtime assets directory")
-        .option("--natives-dir <path>", "Runtime natives directory")
-        .action(wrapCommand(async (context, { options }) => {
-        return downloadClientMod(context, options);
+        .command("create")
+        .description("Create a new client instance")
+        .argument("<name>", "Client instance name (e.g. fabric-1.20.4)")
+        .option("--version <version>", "Minecraft version (default: 1.21.4)")
+        .option("--loader <loader>", "Client loader: fabric (default: fabric)")
+        .option("--ws-port <port>", "WebSocket port (auto-assigned if omitted)", Number)
+        .option("--account <account>", "Offline username or account identifier")
+        .option("--headless", "Launch in headless mode")
+        .option("--java <command>", "Java command to use")
+        .action(wrapCommand(async (_context, { args, options }) => {
+        const clientName = args[0];
+        const loader = options.loader ?? "fabric";
+        const version = options.version ?? "1.21.4";
+        const cacheManager = new CacheManager();
+        const catalog = await loadModVariantCatalog();
+        const variant = findVariantByVersionAndLoader(catalog, version, loader);
+        if (!variant) {
+            throw new MctError({ code: "VARIANT_NOT_FOUND", message: `No mod variant found for ${version} / ${loader}` }, 4);
+        }
+        if (variant.loader !== "fabric") {
+            throw new MctError({ code: "UNSUPPORTED_LOADER", message: `Loader ${variant.loader} is not implemented yet` }, 4);
+        }
+        // Check Java
+        const java = await detectJava(options.java ?? "java");
+        const requiredJava = variant.javaVersion ?? 17;
+        if (!java.available || (java.majorVersion ?? 0) < requiredJava) {
+            throw new MctError({ code: "JAVA_NOT_FOUND", message: `Java ${requiredJava}+ is required for ${variant.id}` }, 4);
+        }
+        // Resolve mod artifact
+        const artifactFileName = getModArtifactFileName(variant);
+        const cacheArtifactPath = cacheManager.getModFile(artifactFileName);
+        const gradleModule = variant.gradleModule ?? `version-${variant.minecraftVersion}`;
+        const localBuildPath = path.join(process.cwd(), "client-mod", gradleModule, "build", "libs", artifactFileName);
+        let sourcePath;
+        try {
+            await access(localBuildPath);
+            sourcePath = localBuildPath;
+            await copyFileIfMissing(localBuildPath, cacheArtifactPath);
+        }
+        catch {
+            try {
+                await access(cacheArtifactPath);
+                sourcePath = cacheArtifactPath;
+            }
+            catch {
+                const modVersion = variant.modVersion ?? "0.1.0";
+                const baseUrl = process.env.MCT_MOD_DOWNLOAD_BASE_URL || "https://github.com/kzheart/mc-pilot/releases/download";
+                const downloadUrl = `${baseUrl}/v${modVersion}/${artifactFileName}`;
+                await downloadFile(downloadUrl, cacheArtifactPath, fetch);
+                sourcePath = cacheArtifactPath;
+            }
+        }
+        // Set up client instance directory
+        const instanceDir = resolveClientInstanceDir(clientName);
+        const minecraftDir = path.join(instanceDir, "minecraft");
+        const modsDir = path.join(minecraftDir, "mods");
+        await mkdir(modsDir, { recursive: true });
+        await copyFileIfMissing(sourcePath, path.join(modsDir, artifactFileName));
+        // Prepare Fabric runtime
+        const runtimeRootDir = path.join(cacheManager.getRootDir(), "client", "runtime", variant.minecraftVersion);
+        const managedRuntime = await prepareManagedFabricRuntime(variant, {
+            runtimeRootDir,
+            gameDir: minecraftDir
+        }, { fetchImpl: fetch });
+        const launchArgs = [
+            "--runtime-root", managedRuntime.runtimeRootDir,
+            "--version-id", managedRuntime.versionId,
+            "--game-dir", managedRuntime.gameDir
+        ];
+        const manager = new ClientInstanceManager(_context.globalState);
+        const meta = await manager.create({
+            name: clientName,
+            loader,
+            version: variant.minecraftVersion,
+            wsPort: options.wsPort,
+            account: options.account,
+            headless: options.headless,
+            launchArgs,
+            env: {
+                MCT_CLIENT_MOD_VARIANT: variant.id,
+                MCT_CLIENT_MOD_JAR: path.join(modsDir, artifactFileName)
+            }
+        });
+        return {
+            created: true,
+            ...meta,
+            javaCommand: java.command,
+            javaVersion: java.majorVersion,
+            modsDir,
+            runtimeRootDir: managedRuntime.runtimeRootDir,
+            runtimeVersionId: managedRuntime.versionId
+        };
     }));
     command
         .command("launch")
         .description("Launch a client instance")
-        .argument("<name>", "Client name (matches a key in config \"clients\", e.g. \"default\")")
-        .option("--version <version>", "Minecraft version")
+        .argument("[name]", "Client instance name (default: from active profile)")
         .option("--server <address>", "Target server address (e.g. localhost:25565)")
         .option("--account <account>", "Offline username or account identifier")
-        .option("--ws-port <port>", "WebSocket port (default: 25560)", Number)
-        .option("--headless", "Launch in headless mode (window hidden)")
+        .option("--ws-port <port>", "WebSocket port override", Number)
+        .option("--headless", "Launch in headless mode")
         .action(wrapCommand(async (context, { args, options }) => {
-        const manager = new ClientManager(context);
-        return manager.launch({
-            name: args[0],
-            ...options
-        });
+        const clientName = args[0] ?? context.activeProfile?.clients[0];
+        if (!clientName) {
+            throw new MctError({ code: "INVALID_PARAMS", message: "Client name is required. Specify it as argument or set a profile." }, 4);
+        }
+        const manager = new ClientInstanceManager(context.globalState);
+        return manager.launch(clientName, options);
     }));
     command
         .command("stop")
         .description("Stop a client instance")
-        .argument("<name>", "Client name")
+        .argument("<name>", "Client instance name")
         .action(wrapCommand(async (context, { args }) => {
-        const manager = new ClientManager(context);
+        const manager = new ClientInstanceManager(context.globalState);
         return manager.stop(args[0]);
     }));
     command
         .command("list")
         .description("List all client instances and their status")
         .action(wrapCommand(async (context) => {
-        const manager = new ClientManager(context);
+        const manager = new ClientInstanceManager(context.globalState);
         return manager.list();
     }));
     command
         .command("wait-ready")
         .description("Wait until client WebSocket is connected")
-        .argument("<name>", "Client name")
+        .argument("[name]", "Client instance name (default: from active profile)")
         .option("--timeout <seconds>", "Timeout in seconds", Number)
         .action(wrapCommand(async (context, { args, options }) => {
-        const manager = new ClientManager(context);
-        return manager.waitReady(args[0], options.timeout ?? context.config.timeout.clientReady);
+        const clientName = args[0] ?? context.activeProfile?.clients[0];
+        if (!clientName) {
+            throw new MctError({ code: "INVALID_PARAMS", message: "Client name is required" }, 4);
+        }
+        const manager = new ClientInstanceManager(context.globalState);
+        return manager.waitReady(clientName, options.timeout ?? context.timeout("clientReady"));
     }));
     command
         .command("reconnect")
         .description("Reconnect the client to the server")
-        .option("--address <address>", "Target server address (default: from launch config)")
+        .option("--address <address>", "Target server address")
         .action(createRequestAction("client.reconnect", ({ options }) => ({
         address: options.address
     })));

package/dist/commands/combat.js

@@ -20,7 +20,7 @@ export function createCombatCommand() {
             .action(createRequestAction(`combat.${actionName}`, ({ options }) => ({
             filter: buildEntityFilter(options),
             timeout: options.timeout
-        }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 30, context.config.timeout.default)));
+        }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 30, context.timeout("default"))));
     }
     command
         .command("clear")
@@ -32,7 +32,7 @@ export function createCombatCommand() {
         type: options.type,
         radius: options.radius ?? 16,
         timeout: options.timeout
-    }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 60, context.config.timeout.default)));
+    }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 60, context.timeout("default"))));
     command
         .command("pickup")
         .description("Pick up nearby dropped items")
@@ -41,6 +41,6 @@ export function createCombatCommand() {
         .action(createRequestAction("combat.pickup", ({ options }) => ({
         radius: options.radius ?? 5,
         timeout: options.timeout
-    }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 10, context.config.timeout.default)));
+    }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 10, context.timeout("default"))));
     return command;
 }

package/dist/commands/gui.js

@@ -34,12 +34,12 @@ export function createGuiCommand() {
         .command("wait-open")
         .description("Wait for a GUI to open")
         .option("--timeout <seconds>", "Timeout in seconds", Number)
-        .action(createRequestAction("gui.wait-open", ({ options }) => ({ timeout: options.timeout }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.config.timeout.default)));
+        .action(createRequestAction("gui.wait-open", ({ options }) => ({ timeout: options.timeout }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.timeout("default"))));
     command
         .command("wait-update")
         .description("Wait for the GUI to update")
         .option("--timeout <seconds>", "Timeout in seconds", Number)
-        .action(createRequestAction("gui.wait-update", ({ options }) => ({ timeout: options.timeout }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.config.timeout.default)));
+        .action(createRequestAction("gui.wait-update", ({ options }) => ({ timeout: options.timeout }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : undefined, context.timeout("default"))));
     command
         .command("screenshot")
         .description("Take a screenshot of the current GUI")

package/dist/commands/input.js

@@ -86,7 +86,7 @@ export function createInputCommand() {
         .action(createRequestAction("input.key-hold", ({ args, options }) => ({
         key: String(args[0]),
         duration: Number(options.duration)
-    }), ({ options }, context) => withTransportTimeoutBuffer(Math.max(Number(options.duration ?? 0) / 1000 + 2, 3), context.config.timeout.default)));
+    }), ({ options }, context) => withTransportTimeoutBuffer(Math.max(Number(options.duration ?? 0) / 1000 + 2, 3), context.timeout("default"))));
     keyCommand
         .command("down")
         .description("Press a key down (without releasing)")

package/dist/commands/move.js

@@ -12,7 +12,7 @@ export function createMoveCommand() {
         x: Number(args[0]),
         y: Number(args[1]),
         z: Number(args[2])
-    }), (_payload, context) => withTransportTimeoutBuffer(30, context.config.timeout.default)));
+    }), (_payload, context) => withTransportTimeoutBuffer(30, context.timeout("default"))));
     const directionLabels = { forward: "Move forward", back: "Move backward", left: "Move left", right: "Move right" };
     for (const direction of ["forward", "back", "left", "right"]) {
         command
@@ -25,7 +25,7 @@ export function createMoveCommand() {
         }), ({ args }, context) => {
             const blocks = Math.abs(Number(args[0]));
             const timeout = Math.max(1.5, blocks * 2.0);
-            return withTransportTimeoutBuffer(timeout, context.config.timeout.default);
+            return withTransportTimeoutBuffer(timeout, context.timeout("default"));
         }));
     }
     command

package/dist/commands/project.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+export declare function createInitCommand(): Command;
+export declare function createDeployCommand(): Command;
+export declare function createUpCommand(): Command;
+export declare function createDownCommand(): Command;
+export declare function createUseCommand(): Command;

package/dist/commands/project.js

@@ -0,0 +1,155 @@
+import { Command } from "commander";
+import path from "node:path";
+import { ServerInstanceManager } from "../instance/ServerInstanceManager.js";
+import { ClientInstanceManager } from "../instance/ClientInstanceManager.js";
+import { MctError } from "../util/errors.js";
+import { wrapCommand } from "../util/command.js";
+import { loadProjectFile, resolveProfile, writeProjectFile } from "../util/project.js";
+export function createInitCommand() {
+    return new Command("init")
+        .description("Initialize a new MC Pilot project in the current directory")
+        .option("--name <name>", "Project name (default: directory name)")
+        .action(wrapCommand(async (context, { options }) => {
+        const existing = await loadProjectFile(context.cwd);
+        if (existing) {
+            throw new MctError({ code: "PROJECT_EXISTS", message: "mct.project.json already exists in this directory" }, 4);
+        }
+        const projectName = options.name ?? path.basename(context.cwd);
+        const project = {
+            project: projectName,
+            profiles: {},
+            screenshot: {
+                outputDir: "./screenshots"
+            },
+            timeout: {
+                serverReady: 120,
+                clientReady: 60,
+                default: 10
+            }
+        };
+        await writeProjectFile(context.cwd, project);
+        return {
+            created: true,
+            project: projectName,
+            file: "mct.project.json"
+        };
+    }));
+}
+export function createDeployCommand() {
+    return new Command("deploy")
+        .description("Deploy plugin JARs to the server instance")
+        .option("--profile <name>", "Profile name")
+        .action(wrapCommand(async (context, { options }) => {
+        const { projectFile, projectName } = context;
+        if (!projectFile || !projectName) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
+        }
+        const profile = resolveProfile(projectFile, options.profile ?? projectFile.defaultProfile);
+        if (!profile) {
+            throw new MctError({ code: "NO_PROFILE", message: "No profile specified and no defaultProfile set" }, 4);
+        }
+        if (!profile.deployPlugins || profile.deployPlugins.length === 0) {
+            return { deployed: [], message: "No deployPlugins configured in profile" };
+        }
+        const manager = new ServerInstanceManager(context.globalState, projectName);
+        const deployed = await manager.deploy(profile.server, profile.deployPlugins, context.cwd);
+        return { deployed, server: profile.server };
+    }));
+}
+export function createUpCommand() {
+    return new Command("up")
+        .description("Deploy plugins, start server and clients, wait for ready")
+        .option("--profile <name>", "Profile name")
+        .option("--eula", "Auto-accept EULA")
+        .action(wrapCommand(async (context, { options }) => {
+        const { projectFile, projectName } = context;
+        if (!projectFile || !projectName) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
+        }
+        const profile = resolveProfile(projectFile, options.profile ?? projectFile.defaultProfile);
+        if (!profile) {
+            throw new MctError({ code: "NO_PROFILE", message: "No profile specified and no defaultProfile set" }, 4);
+        }
+        const serverManager = new ServerInstanceManager(context.globalState, projectName);
+        const clientManager = new ClientInstanceManager(context.globalState);
+        const results = {};
+        // 1. Deploy plugins
+        if (profile.deployPlugins && profile.deployPlugins.length > 0) {
+            results.deployed = await serverManager.deploy(profile.server, profile.deployPlugins, context.cwd);
+        }
+        // 2. Start server
+        results.server = await serverManager.start(profile.server, { eula: options.eula });
+        // 3. Wait for server
+        const serverMeta = await serverManager.loadMeta(profile.server);
+        await serverManager.waitReady(profile.server, context.timeout("serverReady"));
+        // 4. Launch clients
+        const clientResults = [];
+        for (const clientName of profile.clients) {
+            const result = await clientManager.launch(clientName, {
+                server: `localhost:${serverMeta.port}`
+            });
+            clientResults.push(result);
+        }
+        results.clients = clientResults;
+        // 5. Wait for clients
+        for (const clientName of profile.clients) {
+            await clientManager.waitReady(clientName, context.timeout("clientReady"));
+        }
+        results.ready = true;
+        return results;
+    }));
+}
+export function createDownCommand() {
+    return new Command("down")
+        .description("Stop server and clients for the active profile")
+        .option("--profile <name>", "Profile name")
+        .action(wrapCommand(async (context, { options }) => {
+        const { projectFile, projectName } = context;
+        if (!projectFile || !projectName) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
+        }
+        const profile = resolveProfile(projectFile, options.profile ?? projectFile.defaultProfile);
+        if (!profile) {
+            throw new MctError({ code: "NO_PROFILE", message: "No profile specified and no defaultProfile set" }, 4);
+        }
+        const serverManager = new ServerInstanceManager(context.globalState, projectName);
+        const clientManager = new ClientInstanceManager(context.globalState);
+        const results = {};
+        // Stop clients first
+        const clientResults = [];
+        for (const clientName of profile.clients) {
+            const result = await clientManager.stop(clientName);
+            clientResults.push(result);
+        }
+        results.clients = clientResults;
+        // Stop server
+        results.server = await serverManager.stop(profile.server);
+        return results;
+    }));
+}
+export function createUseCommand() {
+    return new Command("use")
+        .description("Set the default profile")
+        .argument("<profile>", "Profile name to set as default")
+        .action(wrapCommand(async (context, { args }) => {
+        const { projectFile } = context;
+        if (!projectFile) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
+        }
+        const profileName = args[0];
+        if (!projectFile.profiles[profileName]) {
+            const available = Object.keys(projectFile.profiles);
+            throw new MctError({
+                code: "PROFILE_NOT_FOUND",
+                message: `Profile '${profileName}' not found`,
+                details: { available }
+            }, 4);
+        }
+        projectFile.defaultProfile = profileName;
+        await writeProjectFile(context.cwd, projectFile);
+        return {
+            defaultProfile: profileName,
+            profile: projectFile.profiles[profileName]
+        };
+    }));
+}

package/dist/commands/request-helpers.js

@@ -1,13 +1,13 @@
 import { Command } from "commander";
-import { ClientManager } from "../client/ClientManager.js";
+import { ClientInstanceManager } from "../instance/ClientInstanceManager.js";
 import { WebSocketClient } from "../client/WebSocketClient.js";
 import { MctError } from "../util/errors.js";
 import { wrapCommand } from "../util/command.js";
 export async function sendClientRequest(context, clientName, action, params, timeoutSeconds) {
-    const manager = new ClientManager(context);
+    const manager = new ClientInstanceManager(context.globalState);
     const client = await manager.getClient(clientName);
-    const ws = new WebSocketClient(manager.getWsUrl(client.wsPort));
-    return ws.send(action, params, timeoutSeconds ?? context.config.timeout.default);
+    const ws = new WebSocketClient(`ws://127.0.0.1:${client.wsPort}`);
+    return ws.send(action, params, timeoutSeconds ?? context.timeout("default"));
 }
 export function createRequestAction(action, buildParams, timeoutSelector) {
     return wrapCommand(async (context, payload) => {

package/dist/commands/server.js

@@ -1,10 +1,24 @@
 import { Command } from "commander";
 import { buildServerSearchResults } from "../download/SearchCommand.js";
-import { downloadServerJar } from "../download/server/ServerDownloader.js";
+import { downloadServerJarToCache } from "../download/server/ServerDownloader.js";
+import { ServerInstanceManager } from "../instance/ServerInstanceManager.js";
+import { MctError } from "../util/errors.js";
 import { wrapCommand } from "../util/command.js";
-import { ServerManager } from "../server/ServerManager.js";
+function requireProject(context) {
+    if (!context.projectName) {
+        throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first or use --project <name>" }, 4);
+    }
+    return context.projectName;
+}
+function resolveServerName(context, explicit) {
+    if (explicit)
+        return explicit;
+    if (context.activeProfile?.server)
+        return context.activeProfile.server;
+    throw new MctError({ code: "INVALID_PARAMS", message: "Server name is required. Specify it as argument or set a profile." }, 4);
+}
 export function createServerCommand() {
-    const command = new Command("server").description("Manage Minecraft server");
+    const command = new Command("server").description("Manage Minecraft server instances");
     command
         .command("search")
         .description("Search available server versions")
@@ -19,48 +33,88 @@ export function createServerCommand() {
         };
     }));
     command
-        .command("download")
-        .description("Download server jar and update config")
-        .option("--type <type>", "Server type: vanilla|paper|purpur|spigot")
-        .option("--version <version>", "Minecraft version")
+        .command("create")
+        .description("Create a new server instance")
+        .argument("<name>", "Server instance name (e.g. paper-1.20.4)")
+        .option("--type <type>", "Server type: vanilla|paper|purpur|spigot (default: paper)")
+        .option("--version <version>", "Minecraft version (default: 1.21.4)")
         .option("--build <build>", "Specific build number")
-        .option("--dir <path>", "Download target directory")
-        .option("--fixtures <path>", "Fixture plugin jar, auto-copied to plugins/")
-        .action(wrapCommand(async (context, { options }) => {
-        return downloadServerJar(context, options);
+        .option("--port <number>", "Server port (auto-assigned if omitted)", Number)
+        .option("--jvm-args <args>", "JVM arguments (comma-separated)")
+        .option("--eula", "Auto-accept EULA")
+        .action(wrapCommand(async (context, { args, options }) => {
+        const project = requireProject(context);
+        const serverType = (options.type ?? "paper");
+        const version = options.version ?? "1.21.4";
+        const downloadResult = await downloadServerJarToCache({ type: serverType, version, build: options.build });
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return manager.create({
+            name: args[0],
+            project,
+            type: serverType,
+            version,
+            port: options.port,
+            jvmArgs: options.jvmArgs?.split(",").map(a => a.trim()) ?? [],
+            eula: options.eula,
+            cachedJarPath: downloadResult.cachePath
+        });
     }));
     command
         .command("start")
-        .description("Start the server")
-        .option("--jar <path>", "Server jar path (default: from config server.jar)")
-        .option("--dir <path>", "Server directory (default: from config server.dir)")
-        .option("--port <number>", "Server port (default: 25565)", Number)
+        .description("Start a server instance")
+        .argument("[name]", "Server instance name (default: from active profile)")
         .option("--eula", "Auto-accept EULA")
-        .action(wrapCommand(async (context, { options }) => {
-        const manager = new ServerManager(context);
-        return manager.start(options);
+        .option("--jvm-args <args>", "Override JVM arguments (comma-separated)")
+        .action(wrapCommand(async (context, { args, options }) => {
+        const project = requireProject(context);
+        const serverName = resolveServerName(context, args[0]);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return manager.start(serverName, {
+            eula: options.eula,
+            jvmArgs: options.jvmArgs?.split(",").map(a => a.trim())
+        });
     }));
     command
         .command("stop")
-        .description("Stop the server")
-        .action(wrapCommand(async (context) => {
-        const manager = new ServerManager(context);
-        return manager.stop();
+        .description("Stop a server instance")
+        .argument("[name]", "Server instance name (default: from active profile)")
+        .action(wrapCommand(async (context, { args }) => {
+        const project = requireProject(context);
+        const serverName = resolveServerName(context, args[0]);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return manager.stop(serverName);
     }));
     command
         .command("status")
         .description("Show server status")
-        .action(wrapCommand(async (context) => {
-        const manager = new ServerManager(context);
-        return manager.status();
+        .argument("[name]", "Server instance name (omit to show all in project)")
+        .action(wrapCommand(async (context, { args }) => {
+        const project = requireProject(context);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return manager.status(args[0]);
+    }));
+    command
+        .command("list")
+        .description("List server instances")
+        .option("--all", "List instances across all projects")
+        .action(wrapCommand(async (context, { options }) => {
+        if (options.all) {
+            return { instances: await ServerInstanceManager.listAll(context.globalState) };
+        }
+        const project = requireProject(context);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return { instances: await manager.list() };
     }));
     command
         .command("wait-ready")
         .description("Wait until server port is connectable")
+        .argument("[name]", "Server instance name (default: from active profile)")
         .option("--timeout <seconds>", "Timeout in seconds", Number)
-        .action(wrapCommand(async (context, { options }) => {
-        const manager = new ServerManager(context);
-        return manager.waitReady(options.timeout ?? context.config.timeout.serverReady);
+        .action(wrapCommand(async (context, { args, options }) => {
+        const project = requireProject(context);
+        const serverName = resolveServerName(context, args[0]);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return manager.waitReady(serverName, options.timeout ?? context.timeout("serverReady"));
     }));
     return command;
 }

package/dist/commands/wait.js

@@ -17,7 +17,7 @@ export function createWaitCommand() {
         untilOnGround: Boolean(options.untilOnGround),
         timeout: options.timeout
     }), ({ options, args }, context) => {
-        const requested = options.timeout ? Number(options.timeout) : args[0] ? Number(args[0]) : context.config.timeout.default;
-        return withTransportTimeoutBuffer(requested, context.config.timeout.default);
+        const requested = options.timeout ? Number(options.timeout) : args[0] ? Number(args[0]) : context.timeout("default");
+        return withTransportTimeoutBuffer(requested, context.timeout("default"));
     }));
 }

package/dist/download/VersionMatrix.d.ts

@@ -46,8 +46,8 @@ export declare function getVersionMatrix(): {
     servers: {
         paper: ServerSupportInfo;
         purpur: ServerSupportInfo;
-        spigot: ServerSupportInfo;
         vanilla: ServerSupportInfo;
+        spigot: ServerSupportInfo;
     };
     clients: {
         fabric: ClientLoaderSupportInfo;