@kzheart_/mc-pilot 0.5.0 → 0.7.0

package/dist/commands/chat.js

@@ -1,17 +1,79 @@
 import { Command } from "commander";
-import { createRequestAction, withTransportTimeoutBuffer } from "./request-helpers.js";
+import { ServerInstanceManager } from "../instance/ServerInstanceManager.js";
+import { MctError } from "../util/errors.js";
+import { wrapCommand } from "../util/command.js";
+import { createRequestAction, resolvePreferredClientName, sendClientRequest, withTransportTimeoutBuffer } from "./request-helpers.js";
+function normalizeChatCommand(text) {
+    const command = text?.trim();
+    if (!command) {
+        throw new MctError({ code: "INVALID_PARAMS", message: "Command is required" }, 4);
+    }
+    return command;
+}
+async function executeServerCommand(context, serverName, command) {
+    const manager = new ServerInstanceManager(context.globalState, context.projectName);
+    const result = await manager.exec(serverName, command);
+    return {
+        ...result,
+        warning: "Commands that require a player sender should use --via client."
+    };
+}
 export function createChatCommand() {
     const command = new Command("chat").description("Chat and server commands");
     command
         .command("send")
-        .description("Send a chat message")
+        .description("Send a chat message. Slash-prefixed text is routed as a player command unless --literal is set.")
         .argument("<message>", "Message text")
-        .action(createRequestAction("chat.send", ({ args }) => ({ message: args[0] })));
+        .option("--literal", "Send slash-prefixed text as plain chat instead of a command packet")
+        .action(wrapCommand(async (context, { args, options, globalOptions }) => {
+        const message = args[0] ?? "";
+        const preferredClient = resolvePreferredClientName(context, globalOptions);
+        if (!options.literal && message.trim().startsWith("/")) {
+            return sendClientRequest(context, preferredClient, "chat.command", { command: message });
+        }
+        return sendClientRequest(context, preferredClient, "chat.send", { message });
+    }));
     command
         .command("command")
-        .description("Execute a server command (no / prefix needed)")
-        .argument("<command>", "Command text, e.g. \"gamemode creative\"")
-        .action(createRequestAction("chat.command", ({ args }) => ({ command: args[0] })));
+        .description("Execute a command. Defaults to auto-routing: prefer player context when a client is available, otherwise use server stdin.")
+        .argument("<command>", "Command text, e.g. \"gamemode creative\" (leading slash optional)")
+        .option("--via <target>", "Delivery channel: auto (default), server (stdin FIFO), or client (client WS)", "auto")
+        .option("--server <name>", "Server instance name when --via server (default: active profile server)")
+        .action(wrapCommand(async (context, { args, options, globalOptions }) => {
+        const via = options.via ?? "auto";
+        const commandText = normalizeChatCommand(args[0]);
+        const preferredClient = resolvePreferredClientName(context, globalOptions);
+        if (via === "client") {
+            return sendClientRequest(context, preferredClient, "chat.command", { command: commandText });
+        }
+        if (via === "auto") {
+            if (preferredClient) {
+                return sendClientRequest(context, preferredClient, "chat.command", { command: commandText });
+            }
+            if (!context.projectName) {
+                return sendClientRequest(context, undefined, "chat.command", { command: commandText });
+            }
+            const serverName = options.server ?? context.activeProfile?.server;
+            if (!serverName) {
+                throw new MctError({
+                    code: "INVALID_PARAMS",
+                    message: "No client context is available, and auto-routing could not resolve a server. Use --client, --server, or run inside a project profile."
+                }, 4);
+            }
+            return executeServerCommand(context, serverName, commandText);
+        }
+        if (via !== "server") {
+            throw new MctError({ code: "INVALID_PARAMS", message: `--via must be \"auto\", \"server\" or \"client\", got: ${via}` }, 4);
+        }
+        if (!context.projectName) {
+            throw new MctError({ code: "NO_PROJECT", message: "--via server requires a project context. Use --via client or run inside an mct project." }, 4);
+        }
+        const serverName = options.server ?? context.activeProfile?.server;
+        if (!serverName) {
+            throw new MctError({ code: "INVALID_PARAMS", message: "--via server requires --server <name> or an active profile with a server." }, 4);
+        }
+        return executeServerCommand(context, serverName, commandText);
+    }));
     command
         .command("history")
         .description("Get chat history")
@@ -27,5 +89,9 @@ export function createChatCommand() {
         .command("last")
         .description("Get the last chat message")
         .action(createRequestAction("chat.last", () => ({})));
+    command
+        .command("clear")
+        .description("Clear the cached chat history tracked by the client mod")
+        .action(createRequestAction("chat.clear", () => ({})));
     return command;
 }

package/dist/commands/client.d.ts

@@ -1,2 +1,4 @@
 import { Command } from "commander";
+import type { CommandContext } from "../util/context.js";
+export declare function resolveProfileServerAddress(context: Pick<CommandContext, "projectName" | "activeProfile" | "globalState">, explicitServer: string | undefined, loadPort?: (projectName: string, serverName: string) => Promise<number>): Promise<string | undefined>;
 export declare function createClientCommand(): Command;

package/dist/commands/client.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { buildClientSearchResults } from "../download/SearchCommand.js";
 import { ClientInstanceManager } from "../instance/ClientInstanceManager.js";
+import { ServerInstanceManager } from "../instance/ServerInstanceManager.js";
 import { MctError } from "../util/errors.js";
 import { createRequestAction } from "./request-helpers.js";
 import { wrapCommand } from "../util/command.js";
@@ -12,6 +13,23 @@ 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 async function resolveProfileServerAddress(context, explicitServer, loadPort) {
+    if (explicitServer) {
+        return explicitServer;
+    }
+    if (!context.projectName || !context.activeProfile?.server) {
+        return undefined;
+    }
+    try {
+        const port = loadPort
+            ? await loadPort(context.projectName, context.activeProfile.server)
+            : (await new ServerInstanceManager(context.globalState, context.projectName).loadMeta(context.activeProfile.server)).port;
+        return `127.0.0.1:${port}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function createClientCommand() {
     const command = new Command("client").description("Manage Minecraft client instances");
     command
@@ -125,7 +143,7 @@ export function createClientCommand() {
         .command("launch")
         .description("Launch a client instance")
         .argument("[name]", "Client instance name (default: from active profile)")
-        .option("--server <address>", "Target server address (e.g. localhost:25565)")
+        .option("--server <address>", "Target server address (default: active profile server, e.g. localhost:25565)")
         .option("--account <account>", "Offline username or account identifier")
         .option("--ws-port <port>", "WebSocket port override", Number)
         .option("--headless", "Launch in headless mode")
@@ -136,7 +154,11 @@ export function createClientCommand() {
             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);
+        const serverAddress = await resolveProfileServerAddress(context, options.server);
+        return manager.launch(clientName, {
+            ...options,
+            server: serverAddress
+        });
     }));
     command
         .command("stop")
@@ -176,5 +198,9 @@ export function createClientCommand() {
         .action(createRequestAction("client.reconnect", ({ options }) => ({
         address: options.address
     })));
+    command
+        .command("respawn")
+        .description("Respawn the player after death (sends C2S respawn packet, bypasses DeathScreen auto-respawn)")
+        .action(createRequestAction("client.respawn", () => ({})));
     return command;
 }

package/dist/commands/input.js

@@ -102,10 +102,7 @@ export function createInputCommand() {
         .description("Press a key combination in sequence")
         .argument("<keys...>", "Key names")
         .action(createRequestAction("input.key-combo", ({ args }) => ({
-        keys: String(args[0])
-            .split(",")
-            .map((value) => value.trim())
-            .filter(Boolean)
+        keys: args.filter((v) => v !== undefined)
     })));
     command
         .command("type")

package/dist/commands/plugin.js

@@ -83,7 +83,7 @@ export function createPluginCommand() {
         .argument("<ids...>", "Plugin IDs to resolve")
         .action(wrapCommand(async (_context, { args }) => {
         const manager = new PluginCatalogManager();
-        const resolved = await manager.resolve(args);
+        const resolved = await manager.resolve(args.filter((v) => v !== undefined));
         return {
             order: resolved.map((p) => p.id),
             plugins: resolved

package/dist/commands/request-helpers.d.ts

@@ -1,11 +1,12 @@
 import { Command } from "commander";
 import type { CommandContext, GlobalOptions } from "../util/context.js";
 export interface RequestPayload<TOptions> {
-    args: string[];
+    args: (string | undefined)[];
     options: TOptions;
     globalOptions: GlobalOptions;
 }
 export declare function sendClientRequest(context: CommandContext, clientName: string | undefined, action: string, params: Record<string, unknown>, timeoutSeconds?: number): Promise<unknown>;
+export declare function resolvePreferredClientName(context: CommandContext, globalOptions: GlobalOptions): string | undefined;
 export declare function createRequestAction<TOptions = Record<string, any>>(action: string, buildParams: (payload: RequestPayload<TOptions>) => Record<string, unknown>, timeoutSelector?: (payload: RequestPayload<TOptions>, context: CommandContext) => number | undefined): (this: Command, ...input: unknown[]) => Promise<void>;
 export declare function parseJson(text: string, fieldName: string): Record<string, unknown>;
 export declare function parseNumberList(text: string): number[];

package/dist/commands/request-helpers.js

@@ -9,10 +9,13 @@ export async function sendClientRequest(context, clientName, action, params, tim
     const ws = new WebSocketClient(`ws://127.0.0.1:${client.wsPort}`);
     return ws.send(action, params, timeoutSeconds ?? context.timeout("default"));
 }
+export function resolvePreferredClientName(context, globalOptions) {
+    return globalOptions.client ?? context.activeProfile?.clients[0];
+}
 export function createRequestAction(action, buildParams, timeoutSelector) {
     return wrapCommand(async (context, payload) => {
         const timeout = timeoutSelector?.(payload, context);
-        return sendClientRequest(context, payload.globalOptions.client, action, buildParams(payload), timeout);
+        return sendClientRequest(context, resolvePreferredClientName(context, payload.globalOptions), action, buildParams(payload), timeout);
     });
 }
 export function parseJson(text, fieldName) {

package/dist/commands/server.js

@@ -88,9 +88,15 @@ export function createServerCommand() {
         .command("status")
         .description("Show server 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);
+        .option("--all", "Show running servers across all projects")
+        .action(wrapCommand(async (context, { args, options }) => {
+        if (options.all || (!context.projectName && !args[0])) {
+            return ServerInstanceManager.statusAll(context.globalState);
+        }
+        if (!context.projectName) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project context. Omit the name to inspect all running servers, or use --project <name>." }, 4);
+        }
+        const manager = new ServerInstanceManager(context.globalState, context.projectName);
         return manager.status(args[0]);
     }));
     command
@@ -116,5 +122,47 @@ export function createServerCommand() {
         const manager = new ServerInstanceManager(context.globalState, project);
         return manager.waitReady(serverName, options.timeout ?? context.timeout("serverReady"));
     }));
+    command
+        .command("exec")
+        .description("Send a console command directly to the server stdin FIFO (bypasses client chat)")
+        .argument("<command...>", "Command text (leading slash optional, e.g. \"say hi\" or \"op TEST1\")")
+        .option("--server <name>", "Server instance name (default: from active profile)")
+        .action(wrapCommand(async (context, { args, options }) => {
+        const project = requireProject(context);
+        const serverName = resolveServerName(context, options.server);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        return manager.exec(serverName, args.filter((v) => v !== undefined).join(" "));
+    }));
+    command
+        .command("logs")
+        .description("Read the server log file (with optional tail/grep/follow)")
+        .argument("[name]", "Server instance name (default: from active profile)")
+        .option("--tail <n>", "Show only the last N lines", Number)
+        .option("--grep <pattern>", "Filter lines by regex")
+        .option("--since <lineNumber>", "Skip the first N lines (0-indexed)", Number)
+        .option("--follow", "Wait for new log lines (requires --timeout)")
+        .option("--timeout <seconds>", "Max seconds to wait when --follow is set", Number)
+        .option("--first-match", "With --follow, exit as soon as the first matching line appears")
+        .option("--raw-colors", "Preserve ANSI color escape sequences in returned lines")
+        .action(wrapCommand(async (context, { args, options }) => {
+        const project = requireProject(context);
+        const serverName = resolveServerName(context, args[0]);
+        const manager = new ServerInstanceManager(context.globalState, project);
+        if (options.follow) {
+            const timeoutSeconds = options.timeout ?? 30;
+            return manager.followLogs(serverName, {
+                grep: options.grep,
+                timeoutSeconds,
+                firstMatchOnly: Boolean(options.firstMatch),
+                rawColors: Boolean(options.rawColors)
+            });
+        }
+        return manager.readLogs(serverName, {
+            tail: options.tail,
+            grep: options.grep,
+            since: options.since,
+            rawColors: Boolean(options.rawColors)
+        });
+    }));
     return command;
 }

package/dist/instance/ClientInstanceManager.js

@@ -244,7 +244,7 @@ export class ClientInstanceManager {
         });
         throw new MctError({
             code: "TIMEOUT",
-            message: `Timed out after ${timeoutSeconds}s waiting for client ${clientName} to join a world (${wsUrl}). ${this.formatDiagnostics(diag)} Tip: try \`mct client reconnect --address <server>\` or \`mct client launch --force\`.`,
+            message: `Timed out after ${timeoutSeconds}s waiting for client ${clientName} to join a world (${wsUrl}). ${this.formatDiagnostics(diag)} Tip: if the client is still at the main menu, run \`mct client reconnect --address <server>\` or relaunch with \`mct client launch --server <address>\` (inside a project, plain \`mct client launch\` uses the active profile server).`,
             details: diag
         }, 2);
     }

package/dist/instance/ServerInstanceManager.d.ts

@@ -1,5 +1,7 @@
 import type { GlobalStateStore } from "../util/global-state.js";
 import type { ServerInstanceMeta, ServerRuntimeEntry, ServerType } from "../util/instance-types.js";
+export declare function stripAnsiCodes(text: string): string;
+export declare function ensureServerPortProperty(instanceDir: string, port: number): Promise<void>;
 export interface CreateServerOptions {
     name: string;
     project: string;
@@ -60,11 +62,44 @@ export declare class ServerInstanceManager {
         stdinPipe?: string;
         running: boolean;
     }>;
+    static statusAll(globalState: GlobalStateStore): Promise<{
+        [key: string]: unknown;
+        running: boolean;
+    }[]>;
     waitReady(serverName: string, timeoutSeconds: number): Promise<{
         reachable: boolean;
         host: string;
         port: number;
     }>;
+    exec(serverName: string, command: string): Promise<{
+        sent: boolean;
+        command: string;
+        stdinPipe: string;
+    }>;
+    readLogs(serverName: string, options?: {
+        tail?: number;
+        grep?: string;
+        since?: number;
+        rawColors?: boolean;
+    }): Promise<{
+        logPath: string;
+        totalLines: number;
+        returnedLines: number;
+        lines: string[];
+    }>;
+    followLogs(serverName: string, options: {
+        grep?: string;
+        timeoutSeconds: number;
+        firstMatchOnly?: boolean;
+        rawColors?: boolean;
+    }): Promise<{
+        logPath: string;
+        matched: boolean;
+        matches: string[];
+        timedOut: boolean;
+    }>;
+    private requireRuntimeEntry;
+    private requireRunning;
     list(): Promise<ServerInstanceMeta[]>;
     static listAll(globalState: GlobalStateStore): Promise<ServerInstanceMeta[]>;
     deploy(serverName: string, jarPaths: string[], cwd: string): Promise<string[]>;

package/dist/instance/ServerInstanceManager.js

@@ -1,5 +1,5 @@
-import { copyFile, mkdir, readdir, readFile, writeFile, unlink } from "node:fs/promises";
-import { mkdirSync, openSync } from "node:fs";
+import { copyFile, mkdir, open as fsOpen, readdir, readFile, stat, writeFile, unlink } from "node:fs/promises";
+import { openSync, writeSync, closeSync, mkdirSync } from "node:fs";
 import { spawn, execSync } from "node:child_process";
 import path from "node:path";
 import { resolveMctHome, resolveProjectDir, resolveServerInstanceDir } from "../util/paths.js";
@@ -8,6 +8,36 @@ import { waitForTcpPort } from "../util/net.js";
 import { isProcessRunning, killProcessTree } from "../util/process.js";
 import { copyFileIfMissing } from "../download/DownloadUtils.js";
 const INSTANCE_FILE = "instance.json";
+const ANSI_ESCAPE_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+export function stripAnsiCodes(text) {
+    return text.replace(ANSI_ESCAPE_PATTERN, "");
+}
+export async function ensureServerPortProperty(instanceDir, port) {
+    const filePath = path.join(instanceDir, "server.properties");
+    let lines = [];
+    try {
+        const raw = await readFile(filePath, "utf8");
+        lines = raw.split(/\r?\n/);
+        if (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+    }
+    catch {
+        // initialize from scratch
+    }
+    let updated = false;
+    lines = lines.map((line) => {
+        if (/^\s*server-port\s*=/.test(line)) {
+            updated = true;
+            return `server-port=${port}`;
+        }
+        return line;
+    });
+    if (!updated) {
+        lines.push(`server-port=${port}`);
+    }
+    await writeFile(filePath, `${lines.join("\n")}\n`, "utf8");
+}
 export class ServerInstanceManager {
     globalState;
     project;
@@ -28,6 +58,7 @@ export class ServerInstanceManager {
             await writeFile(path.join(instanceDir, "eula.txt"), "eula=true\n", "utf8");
         }
         await mkdir(path.join(instanceDir, "plugins"), { recursive: true });
+        await ensureServerPortProperty(instanceDir, port);
         const meta = {
             name: options.name,
             project: options.project,
@@ -56,6 +87,7 @@ export class ServerInstanceManager {
         if (options.eula) {
             await writeFile(path.join(instanceDir, "eula.txt"), "eula=true\n", "utf8");
         }
+        await ensureServerPortProperty(instanceDir, meta.port);
         const mctHome = resolveMctHome();
         const logsDir = path.join(mctHome, "logs");
         const stateDir = path.join(mctHome, "state");
@@ -154,6 +186,19 @@ export class ServerInstanceManager {
         await this.globalState.writeServerState(state);
         return results;
     }
+    static async statusAll(globalState) {
+        const state = await globalState.readServerState();
+        const results = [];
+        for (const [key, entry] of Object.entries(state.servers)) {
+            const running = isProcessRunning(entry.pid);
+            if (!running) {
+                delete state.servers[key];
+            }
+            results.push({ running, ...entry });
+        }
+        await globalState.writeServerState(state);
+        return results;
+    }
     async waitReady(serverName, timeoutSeconds) {
         const stateKey = `${this.project}/${serverName}`;
         const state = await this.globalState.readServerState();
@@ -163,6 +208,143 @@ export class ServerInstanceManager {
         }
         return waitForTcpPort("127.0.0.1", entry.port, timeoutSeconds);
     }
+    async exec(serverName, command) {
+        const entry = await this.requireRunning(serverName);
+        if (!entry.stdinPipe) {
+            throw new MctError({ code: "SERVER_STDIN_UNAVAILABLE", message: `Server ${this.project}/${serverName} has no stdin FIFO (detached mode?)` }, 5);
+        }
+        const trimmed = command.trim();
+        if (!trimmed) {
+            throw new MctError({ code: "INVALID_PARAMS", message: "Command is required" }, 4);
+        }
+        const line = `${trimmed.replace(/^\//, "")}\n`;
+        // O_NONBLOCK write: bash wrapper holds FIFO fd in rw mode so this returns immediately.
+        let fd;
+        try {
+            fd = openSync(entry.stdinPipe, "w");
+        }
+        catch (error) {
+            throw new MctError({ code: "SERVER_STDIN_OPEN_FAILED", message: `Failed to open stdin FIFO: ${error.message}`, details: { stdinPipe: entry.stdinPipe } }, 5);
+        }
+        try {
+            writeSync(fd, line);
+        }
+        finally {
+            closeSync(fd);
+        }
+        return { sent: true, command: trimmed, stdinPipe: entry.stdinPipe };
+    }
+    async readLogs(serverName, options = {}) {
+        const entry = await this.requireRuntimeEntry(serverName);
+        const logPath = entry.logPath;
+        const raw = await readFile(logPath, "utf8").catch((error) => {
+            if (error.code === "ENOENT")
+                return "";
+            throw error;
+        });
+        let lines = raw.split("\n");
+        if (lines.length > 0 && lines[lines.length - 1] === "")
+            lines = lines.slice(0, -1);
+        const total = lines.length;
+        if (!options.rawColors) {
+            lines = lines.map((line) => stripAnsiCodes(line));
+        }
+        if (options.since !== undefined && options.since > 0) {
+            lines = lines.slice(Math.max(0, options.since));
+        }
+        if (options.grep) {
+            const re = new RegExp(options.grep);
+            lines = lines.filter((line) => re.test(line));
+        }
+        if (options.tail !== undefined && options.tail > 0 && lines.length > options.tail) {
+            lines = lines.slice(lines.length - options.tail);
+        }
+        return { logPath, totalLines: total, returnedLines: lines.length, lines };
+    }
+    async followLogs(serverName, options) {
+        const entry = await this.requireRuntimeEntry(serverName);
+        const logPath = entry.logPath;
+        const re = options.grep ? new RegExp(options.grep) : null;
+        let offset = 0;
+        try {
+            offset = (await stat(logPath)).size;
+        }
+        catch { /* file may not exist yet */ }
+        const matches = [];
+        let buffer = "";
+        let done = false;
+        return await new Promise((resolve) => {
+            let timer;
+            let poll;
+            const finish = (timedOut) => {
+                if (done)
+                    return;
+                done = true;
+                if (poll)
+                    clearInterval(poll);
+                if (timer)
+                    clearTimeout(timer);
+                resolve({ logPath, matched: matches.length > 0, matches, timedOut });
+            };
+            const drain = async () => {
+                if (done)
+                    return;
+                let currentSize;
+                try {
+                    currentSize = (await stat(logPath)).size;
+                }
+                catch {
+                    return;
+                }
+                if (currentSize < offset) {
+                    offset = 0;
+                    buffer = "";
+                } // rotation / truncate
+                if (currentSize === offset)
+                    return;
+                // Read raw bytes and decode — stat().size is bytes, not UTF-16 chars.
+                const fh = await fsOpen(logPath, "r");
+                try {
+                    const length = currentSize - offset;
+                    const buf = Buffer.allocUnsafe(length);
+                    await fh.read(buf, 0, length, offset);
+                    offset = currentSize;
+                    buffer += buf.toString("utf8");
+                }
+                finally {
+                    await fh.close();
+                }
+                const parts = buffer.split("\n");
+                buffer = parts.pop() ?? "";
+                for (const line of parts) {
+                    const rendered = options.rawColors ? line : stripAnsiCodes(line);
+                    if (!re || re.test(rendered)) {
+                        matches.push(rendered);
+                        if (options.firstMatchOnly)
+                            return finish(false);
+                    }
+                }
+            };
+            timer = setTimeout(() => finish(true), options.timeoutSeconds * 1000);
+            poll = setInterval(() => { void drain(); }, 300);
+        });
+    }
+    async requireRuntimeEntry(serverName) {
+        const stateKey = `${this.project}/${serverName}`;
+        const state = await this.globalState.readServerState();
+        const entry = state.servers[stateKey];
+        if (!entry) {
+            throw new MctError({ code: "SERVER_NOT_RUNNING", message: `Server ${stateKey} is not running` }, 5);
+        }
+        return entry;
+    }
+    async requireRunning(serverName) {
+        const entry = await this.requireRuntimeEntry(serverName);
+        if (!isProcessRunning(entry.pid)) {
+            throw new MctError({ code: "SERVER_NOT_RUNNING", message: `Server ${this.project}/${serverName} PID ${entry.pid} is not alive` }, 5);
+        }
+        return entry;
+    }
     async list() {
         const projectDir = resolveProjectDir(this.project);
         try {

package/dist/util/command.d.ts

@@ -1,7 +1,7 @@
 import type { Command } from "commander";
 import { createCommandContext, type GlobalOptions } from "./context.js";
 export type CommandAction<TOptions = Record<string, unknown>> = (context: Awaited<ReturnType<typeof createCommandContext>>, payload: {
-    args: string[];
+    args: (string | undefined)[];
     options: TOptions;
     command: Command;
     globalOptions: GlobalOptions;

package/dist/util/command.js

@@ -13,7 +13,13 @@ export function wrapCommand(action) {
     return async function wrappedCommand(...input) {
         const command = input.at(-1);
         const options = input.at(-2);
-        const args = input.slice(0, -2).map((value) => String(value));
+        const args = input.slice(0, -2).flatMap((value) => {
+            if (Array.isArray(value))
+                return value.map((v) => String(v));
+            if (value === undefined || value === null)
+                return [undefined];
+            return [String(value)];
+        });
         const globalOptions = command.optsWithGlobals();
         try {
             const context = await createCommandContext(globalOptions);

package/package.json

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