@kzheart_/mc-pilot 0.4.1 → 0.6.0

package/dist/commands/chat.js

@@ -1,5 +1,8 @@
 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, sendClientRequest, withTransportTimeoutBuffer } from "./request-helpers.js";
 export function createChatCommand() {
     const command = new Command("chat").description("Chat and server commands");
     command
@@ -9,9 +12,28 @@ export function createChatCommand() {
         .action(createRequestAction("chat.send", ({ args }) => ({ message: args[0] })));
     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 server command. Defaults to server stdin FIFO (reliable); use --via client to route through the client's chat.")
+        .argument("<command>", "Command text, e.g. \"gamemode creative\" (leading slash optional)")
+        .option("--via <target>", "Delivery channel: server (stdin FIFO, default) or client (client WS, may fail if chat disabled)", "server")
+        .option("--server <name>", "Server instance name when --via server (default: active profile server)")
+        .action(wrapCommand(async (context, { args, options, globalOptions }) => {
+        const via = options.via ?? "server";
+        if (via === "client") {
+            return sendClientRequest(context, globalOptions.client, "chat.command", { command: args[0] });
+        }
+        if (via !== "server") {
+            throw new MctError({ code: "INVALID_PARAMS", message: `--via must be \"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);
+        }
+        const manager = new ServerInstanceManager(context.globalState, context.projectName);
+        return manager.exec(serverName, args[0]);
+    }));
     command
         .command("history")
         .description("Get chat history")

package/dist/commands/client.js

@@ -176,5 +176,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/events.d.ts

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

package/dist/commands/events.js

@@ -0,0 +1,129 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { MctError } from "../util/errors.js";
+import { resolveMctHome } from "../util/paths.js";
+import { wrapCommand } from "../util/command.js";
+function resolveEventsFile(clientName) {
+    if (!clientName) {
+        throw new MctError({
+            code: "INVALID_PARAMS",
+            message: "Client name is required. Use --client <name> or set an active profile."
+        }, 4);
+    }
+    return path.join(resolveMctHome(), "logs", clientName, "events.jsonl");
+}
+function parseSince(raw, nowMs) {
+    if (!raw)
+        return undefined;
+    const trimmed = raw.trim();
+    // 支持 "30s" / "5m" / "1h" / "200ms" / epoch 毫秒
+    const m = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(trimmed);
+    if (!m) {
+        throw new MctError({ code: "INVALID_PARAMS", message: `Invalid --since value: ${raw}` }, 4);
+    }
+    const value = Number(m[1]);
+    const unit = m[2];
+    if (!unit) {
+        // epoch millis
+        return value;
+    }
+    const multipliers = { ms: 1, s: 1000, m: 60_000, h: 3_600_000 };
+    return nowMs - value * multipliers[unit];
+}
+function readAllEvents(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const raw = readFileSync(filePath, "utf8");
+    const lines = raw.split("\n").filter((line) => line.length > 0);
+    const out = [];
+    for (const line of lines) {
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // 跳过损坏行
+        }
+    }
+    return out;
+}
+export function createEventsCommand() {
+    const command = new Command("events").description("Inspect the client event log (written by the mod to ~/.mct/logs/<client>/events.jsonl)");
+    command
+        .command("list")
+        .description("Print events. Defaults to the last 20 for the active client.")
+        .option("--tail <n>", "Show the last N events (default 20)", (v) => Number(v))
+        .option("--since <duration>", "Only show events since duration ago (e.g. 30s, 5m, 1h) or epoch ms")
+        .option("--type <types>", "Comma-separated list of event types to include")
+        .option("--all", "Show all events (ignore --tail)")
+        .option("--file <path>", "Override the log file path")
+        .action(wrapCommand(async (context, { options, globalOptions }) => {
+        const clientName = globalOptions.client ?? context.activeProfile?.clients[0];
+        const filePath = options.file ?? resolveEventsFile(clientName);
+        const events = readAllEvents(filePath);
+        let filtered = events;
+        const sinceMs = parseSince(options.since, Date.now());
+        if (sinceMs !== undefined) {
+            filtered = filtered.filter((e) => e.t >= sinceMs);
+        }
+        if (options.type) {
+            const wanted = new Set(options.type.split(",").map((s) => s.trim()).filter(Boolean));
+            filtered = filtered.filter((e) => wanted.has(e.type));
+        }
+        if (!options.all) {
+            const tail = options.tail ?? 20;
+            if (filtered.length > tail) {
+                filtered = filtered.slice(filtered.length - tail);
+            }
+        }
+        return {
+            file: filePath,
+            total: events.length,
+            returned: filtered.length,
+            events: filtered
+        };
+    }));
+    command
+        .command("tail")
+        .description("Shortcut for `events list --tail N`")
+        .argument("[n]", "Number of events (default 20)")
+        .option("--type <types>", "Comma-separated event types to include")
+        .option("--file <path>", "Override the log file path")
+        .action(wrapCommand(async (context, { args, options, globalOptions }) => {
+        const tail = args[0] ? Number(args[0]) : 20;
+        const clientName = globalOptions.client ?? context.activeProfile?.clients[0];
+        const filePath = options.file ?? resolveEventsFile(clientName);
+        let events = readAllEvents(filePath);
+        if (options.type) {
+            const wanted = new Set(options.type.split(",").map((s) => s.trim()).filter(Boolean));
+            events = events.filter((e) => wanted.has(e.type));
+        }
+        if (events.length > tail)
+            events = events.slice(events.length - tail);
+        return { file: filePath, returned: events.length, events };
+    }));
+    command
+        .command("clear")
+        .description("Truncate the event log for the active client")
+        .option("--file <path>", "Override the log file path")
+        .action(wrapCommand(async (context, { options, globalOptions }) => {
+        const { truncateSync, existsSync: exists, mkdirSync } = await import("node:fs");
+        const clientName = globalOptions.client ?? context.activeProfile?.clients[0];
+        const filePath = options.file ?? resolveEventsFile(clientName);
+        if (exists(filePath)) {
+            truncateSync(filePath, 0);
+            return { cleared: true, file: filePath };
+        }
+        // ensure directory exists for future writes
+        mkdirSync(path.dirname(filePath), { recursive: true });
+        return { cleared: false, reason: "file_not_found", file: filePath };
+    }));
+    command
+        .command("path")
+        .description("Print the expected path to the event log for the active client")
+        .action(wrapCommand(async (context, { globalOptions }) => {
+        const clientName = globalOptions.client ?? context.activeProfile?.clients[0];
+        return { file: resolveEventsFile(clientName), exists: existsSync(resolveEventsFile(clientName)) };
+    }));
+    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,7 +1,7 @@
 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;
 }

package/dist/commands/server.js

@@ -116,5 +116,44 @@ 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")
+        .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)
+            });
+        }
+        return manager.readLogs(serverName, {
+            tail: options.tail,
+            grep: options.grep,
+            since: options.since
+        });
+    }));
     return command;
 }

package/dist/index.js

@@ -9,6 +9,7 @@ import { createChatCommand } from "./commands/chat.js";
 import { createCombatCommand } from "./commands/combat.js";
 import { createAnvilCommand, createCraftCommand, createEnchantCommand, createTradeCommand } from "./commands/craft.js";
 import { createEntityCommand } from "./commands/entity.js";
+import { createEventsCommand } from "./commands/events.js";
 import { createGuiCommand } from "./commands/gui.js";
 import { createHudCommand } from "./commands/hud.js";
 import { createInputCommand } from "./commands/input.js";
@@ -90,6 +91,7 @@ export function buildProgram() {
     program.addCommand(createEnchantCommand());
     program.addCommand(createTradeCommand());
     program.addCommand(createWaitCommand());
+    program.addCommand(createEventsCommand());
     return program;
 }
 const program = buildProgram();

package/dist/instance/ServerInstanceManager.d.ts

@@ -65,6 +65,33 @@ export declare class ServerInstanceManager {
         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;
+    }): Promise<{
+        logPath: string;
+        totalLines: number;
+        returnedLines: number;
+        lines: string[];
+    }>;
+    followLogs(serverName: string, options: {
+        grep?: string;
+        timeoutSeconds: number;
+        firstMatchOnly?: 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";
@@ -163,6 +163,139 @@ 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.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) {
+                    if (!re || re.test(line)) {
+                        matches.push(line);
+                        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.4.1",
+  "version": "0.6.0",
   "description": "Minecraft plugin/mod automated testing CLI – control a real Minecraft client to simulate player actions",
   "type": "module",
   "bin": {