@kzheart_/mc-pilot 0.7.0 → 0.8.0

package/dist/commands/events.js

@@ -47,6 +47,66 @@ function readAllEvents(filePath) {
     }
     return out;
 }
+function filterEvents(events, options) {
+    let filtered = events;
+    if (options.sinceMs !== undefined) {
+        filtered = filtered.filter((event) => event.t >= options.sinceMs);
+    }
+    if (options.type) {
+        const wanted = new Set(options.type.split(",").map((s) => s.trim()).filter(Boolean));
+        filtered = filtered.filter((event) => wanted.has(event.type));
+    }
+    return filtered;
+}
+function buildPayloadText(event) {
+    return JSON.stringify({
+        type: event.type,
+        payload: event.payload ?? {}
+    });
+}
+function buildMatchPattern(raw) {
+    if (!raw)
+        return null;
+    try {
+        return new RegExp(raw);
+    }
+    catch {
+        throw new MctError({ code: "INVALID_PARAMS", message: `Invalid --match pattern: ${raw}` }, 4);
+    }
+}
+async function waitForEvent(filePath, options) {
+    const deadline = Date.now() + options.timeoutSeconds * 1000;
+    const matchPattern = buildMatchPattern(options.match);
+    const startedAt = Date.now();
+    while (Date.now() < deadline) {
+        const events = filterEvents(readAllEvents(filePath), {
+            sinceMs: options.sinceMs,
+            type: options.type
+        });
+        const matched = matchPattern
+            ? events.find((event) => matchPattern.test(buildPayloadText(event)))
+            : events[0];
+        if (matched) {
+            return {
+                file: filePath,
+                matched: true,
+                waitedMs: Date.now() - startedAt,
+                event: matched
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new MctError({
+        code: "TIMEOUT",
+        message: `Timed out after ${options.timeoutSeconds}s waiting for events in ${filePath}`,
+        details: {
+            file: filePath,
+            type: options.type ?? null,
+            match: options.match ?? null,
+            sinceMs: options.sinceMs
+        }
+    }, 2);
+}
 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
@@ -61,15 +121,10 @@ export function createEventsCommand() {
         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));
-        }
+        let filtered = filterEvents(events, {
+            sinceMs: parseSince(options.since, Date.now()),
+            type: options.type
+        });
         if (!options.all) {
             const tail = options.tail ?? 20;
             if (filtered.length > tail) {
@@ -93,15 +148,31 @@ export function createEventsCommand() {
         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));
-        }
+        let events = filterEvents(readAllEvents(filePath), {
+            type: options.type
+        });
         if (events.length > tail)
             events = events.slice(events.length - tail);
         return { file: filePath, returned: events.length, events };
     }));
+    command
+        .command("wait")
+        .description("Wait for a matching event. Defaults to events emitted after this command starts.")
+        .option("--timeout <seconds>", "Timeout in seconds (default 10)", Number)
+        .option("--since <duration>", "Also consider events since duration ago (e.g. 30s, 5m, 1h) or epoch ms")
+        .option("--type <types>", "Comma-separated list of event types to include")
+        .option("--match <pattern>", "Regex matched against event type and payload JSON")
+        .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);
+        return waitForEvent(filePath, {
+            timeoutSeconds: options.timeout ?? context.timeout("default"),
+            sinceMs: parseSince(options.since, Date.now()) ?? Date.now(),
+            type: options.type,
+            match: options.match
+        });
+    }));
     command
         .command("clear")
         .description("Truncate the event log for the active client")

package/dist/commands/schema.d.ts

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

package/dist/commands/schema.js

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+import { buildSchemaDocument } from "../schema.js";
+import { wrapCommand } from "../util/command.js";
+export function createSchemaCommand(getProgram) {
+    return new Command("schema")
+        .description("Output a machine-readable CLI and protocol schema")
+        .action(wrapCommand(async () => {
+        return buildSchemaDocument(getProgram());
+    }));
+}

package/dist/index.js

@@ -21,6 +21,7 @@ import { createResourcepackCommand } from "./commands/resourcepack.js";
 import { createRotationCommand } from "./commands/rotation.js";
 import { createScreenCommand } from "./commands/screen.js";
 import { createScreenshotCommand } from "./commands/screenshot.js";
+import { createSchemaCommand } from "./commands/schema.js";
 import { createServerCommand } from "./commands/server.js";
 import { createSignCommand } from "./commands/sign.js";
 import { createStatusCommand } from "./commands/status.js";
@@ -67,6 +68,7 @@ export function buildProgram() {
     program.addCommand(createServerCommand());
     program.addCommand(createClientCommand());
     program.addCommand(createPluginCommand());
+    program.addCommand(createSchemaCommand(() => program));
     // Game interaction commands
     program.addCommand(createChatCommand());
     program.addCommand(createInputCommand());

package/dist/schema.d.ts

@@ -0,0 +1,63 @@
+import type { Argument, Command, Option } from "commander";
+interface ProtocolEntry {
+    name?: string;
+    code?: string;
+    description?: string;
+    params?: string[];
+    exitCode?: number;
+}
+declare function serializeOption(option: Option): {
+    name: string;
+    flags: string;
+    description: string;
+    required: boolean;
+    mandatory: boolean;
+    defaultValue: any;
+};
+declare function serializeArgument(argument: Argument): {
+    name: string;
+    required: boolean;
+    variadic: boolean;
+};
+declare function serializeCommand(command: Command, parents?: string[]): {
+    name: string;
+    path: string;
+    description: string;
+    aliases: string[];
+    arguments: ReturnType<typeof serializeArgument>[];
+    options: ReturnType<typeof serializeOption>[];
+    subcommands: ReturnType<typeof serializeCommand>[];
+    leaf: boolean;
+};
+export declare function buildSchemaDocument(program: Command): {
+    schemaVersion: number;
+    cli: {
+        name: string;
+        description: string;
+        globalOptions: {
+            name: string;
+            flags: string;
+            description: string;
+            required: boolean;
+            mandatory: boolean;
+            defaultValue: any;
+        }[];
+        commands: {
+            name: string;
+            path: string;
+            description: string;
+            aliases: string[];
+            arguments: ReturnType<typeof serializeArgument>[];
+            options: ReturnType<typeof serializeOption>[];
+            subcommands: ReturnType<typeof serializeCommand>[];
+            leaf: boolean;
+        }[];
+        leafCommands: string[];
+    };
+    protocol: {
+        actions: number | ProtocolEntry[];
+        queries: number | ProtocolEntry[];
+        errors: number | ProtocolEntry[];
+    };
+};
+export {};

package/dist/schema.js

@@ -0,0 +1,77 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveRepoRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+function loadJsonFile(relativePath) {
+    const filePath = path.join(resolveRepoRoot(), relativePath);
+    return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function serializeOption(option) {
+    return {
+        name: option.name(),
+        flags: option.flags,
+        description: option.description,
+        required: option.required,
+        mandatory: option.mandatory,
+        defaultValue: option.defaultValue
+    };
+}
+function serializeArgument(argument) {
+    return {
+        name: argument.name(),
+        required: argument.required,
+        variadic: argument.variadic
+    };
+}
+function serializeCommand(command, parents = []) {
+    const pathSegments = [...parents, command.name()];
+    return {
+        name: command.name(),
+        path: pathSegments.join(" "),
+        description: command.description(),
+        aliases: command.aliases(),
+        arguments: command.registeredArguments.map(serializeArgument),
+        options: command.options.map(serializeOption),
+        subcommands: command.commands.map((subcommand) => serializeCommand(subcommand, pathSegments)),
+        leaf: command.commands.length === 0
+    };
+}
+function collectLeafCommands(commands) {
+    const leaves = [];
+    const visit = (command) => {
+        if (command.leaf) {
+            leaves.push(command.path);
+            return;
+        }
+        for (const subcommand of command.subcommands) {
+            visit(subcommand);
+        }
+    };
+    for (const command of commands) {
+        visit(command);
+    }
+    return leaves;
+}
+export function buildSchemaDocument(program) {
+    const actions = loadJsonFile("protocol/actions.json");
+    const queries = loadJsonFile("protocol/queries.json");
+    const errors = loadJsonFile("protocol/errors.json");
+    const commands = program.commands.map((command) => serializeCommand(command));
+    return {
+        schemaVersion: 1,
+        cli: {
+            name: program.name(),
+            description: program.description(),
+            globalOptions: program.options.map(serializeOption),
+            commands,
+            leafCommands: collectLeafCommands(commands)
+        },
+        protocol: {
+            actions: actions.actions ?? [],
+            queries: queries.queries ?? [],
+            errors: errors.errors ?? []
+        }
+    };
+}

package/package.json

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