@kzheart_/mc-pilot 0.1.0

package/dist/commands/client.js

@@ -0,0 +1,87 @@
+import { Command } from "commander";
+import { ClientManager } from "../client/ClientManager.js";
+import { downloadClientMod } from "../download/client/ClientDownloader.js";
+import { buildClientSearchResults } from "../download/SearchCommand.js";
+import { createRequestAction } from "./request-helpers.js";
+import { wrapCommand } from "../util/command.js";
+export function createClientCommand() {
+    const command = new Command("client").description("Manage Minecraft client");
+    command
+        .command("search")
+        .description("Search available client version and loader combinations")
+        .option("--loader <loader>", "Client loader: fabric|forge|neoforge")
+        .option("--version <version>", "Minecraft version")
+        .action(wrapCommand(async (_context, { options }) => {
+        return {
+            results: buildClientSearchResults({
+                loader: options.loader,
+                version: options.version
+            })
+        };
+    }));
+    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
+        .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")
+        .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)")
+        .action(wrapCommand(async (context, { args, options }) => {
+        const manager = new ClientManager(context);
+        return manager.launch({
+            name: args[0],
+            ...options
+        });
+    }));
+    command
+        .command("stop")
+        .description("Stop a client instance")
+        .argument("<name>", "Client name")
+        .action(wrapCommand(async (context, { args }) => {
+        const manager = new ClientManager(context);
+        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);
+        return manager.list();
+    }));
+    command
+        .command("wait-ready")
+        .description("Wait until client WebSocket is connected")
+        .argument("<name>", "Client name")
+        .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);
+    }));
+    command
+        .command("reconnect")
+        .description("Reconnect the client to the server")
+        .option("--address <address>", "Target server address (default: from launch config)")
+        .action(createRequestAction("client.reconnect", ({ options }) => ({
+        address: options.address
+    })));
+    return command;
+}

package/dist/commands/combat.d.ts

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

package/dist/commands/combat.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import { buildEntityFilter, createRequestAction, withTransportTimeoutBuffer } from "./request-helpers.js";
+export function createCombatCommand() {
+    const command = new Command("combat").description("Combat combo operations");
+    const combatActionLabels = {
+        kill: "Attack target repeatedly until it dies",
+        engage: "Approach and attack target once",
+        chase: "Chase target without attacking"
+    };
+    for (const actionName of ["kill", "engage", "chase"]) {
+        command
+            .command(actionName)
+            .description(combatActionLabels[actionName])
+            .option("--type <type>", "Entity type (e.g. zombie, skeleton)")
+            .option("--name <name>", "Entity custom name")
+            .option("--nearest", "Target the nearest matching entity")
+            .option("--id <id>", "Entity network ID", Number)
+            .option("--max-distance <distance>", "Max search distance in blocks", Number)
+            .option("--timeout <seconds>", "Timeout in seconds (default: 30)", Number)
+            .action(createRequestAction(`combat.${actionName}`, ({ options }) => ({
+            filter: buildEntityFilter(options),
+            timeout: options.timeout
+        }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 30, context.config.timeout.default)));
+    }
+    command
+        .command("clear")
+        .description("Kill all entities of a type within radius")
+        .requiredOption("--type <type>", "Entity type (e.g. zombie)")
+        .option("--radius <radius>", "Search radius in blocks (default: 16)", Number)
+        .option("--timeout <seconds>", "Timeout in seconds (default: 60)", Number)
+        .action(createRequestAction("combat.clear", ({ options }) => ({
+        type: options.type,
+        radius: options.radius ?? 16,
+        timeout: options.timeout
+    }), ({ options }, context) => withTransportTimeoutBuffer(options.timeout ? Number(options.timeout) : 60, context.config.timeout.default)));
+    command
+        .command("pickup")
+        .description("Pick up nearby dropped items")
+        .option("--radius <radius>", "Pickup radius in blocks (default: 5)", Number)
+        .option("--timeout <seconds>", "Timeout in seconds (default: 10)", Number)
+        .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)));
+    return command;
+}

package/dist/commands/craft.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+export declare function createCraftCommand(): Command;
+export declare function createAnvilCommand(): Command;
+export declare function createEnchantCommand(): Command;
+export declare function createTradeCommand(): Command;

package/dist/commands/craft.js

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import { createRequestAction, parseJson } from "./request-helpers.js";
+export function createCraftCommand() {
+    return new Command("craft")
+        .description("Crafting table recipe\n" +
+        "Prerequisite: open crafting table with \"block interact <x> <y> <z>\"\n" +
+        "Auto-places materials from inventory, crafts, and moves result to inventory.\n" +
+        "GUI closes automatically after crafting.")
+        .requiredOption("--recipe <json>", "Recipe JSON: 9-slot array in row-major order (top-left to bottom-right).\n" +
+        "Use item IDs without namespace (e.g. \"oak_planks\", not \"minecraft:oak_planks\").\n" +
+        "Example: '{\"slots\":[\"oak_planks\",\"oak_planks\",null,\"oak_planks\",\"oak_planks\",null,null,null,null]}'")
+        .action(createRequestAction("craft.craft", ({ options }) => ({ recipe: parseJson(String(options.recipe), "recipe") })));
+}
+export function createAnvilCommand() {
+    return new Command("anvil")
+        .description("Anvil rename operation\n" +
+        "Prerequisite: open anvil with \"block interact <x> <y> <z>\"\n" +
+        "Auto-moves item from inventory slot to anvil, renames it, and moves result back.\n" +
+        "GUI closes automatically.")
+        .requiredOption("--input-slot <slot>", "Inventory slot of the item to rename (0-8: hotbar, 9-35: main)", Number)
+        .requiredOption("--rename <name>", "New item name")
+        .action(createRequestAction("craft.anvil", ({ options }) => ({
+        inputSlot: options.inputSlot,
+        rename: options.rename
+    })));
+}
+export function createEnchantCommand() {
+    return new Command("enchant")
+        .description("Enchanting table operation\n" +
+        "Prerequisite: open enchanting table with \"block interact <x> <y> <z>\"\n" +
+        "You must first place the item and lapis lazuli manually via \"gui click\".\n" +
+        "Use \"gui snapshot\" to inspect slot layout. This command only selects the enchantment option.")
+        .requiredOption("--option <index>", "Enchantment option: 0 = top, 1 = middle, 2 = bottom", Number)
+        .action(createRequestAction("craft.enchant", ({ options }) => ({ option: options.option })));
+}
+export function createTradeCommand() {
+    return new Command("trade")
+        .description("Villager trading\n" +
+        "Prerequisite: open trade GUI with \"entity interact --nearest --type villager\"\n" +
+        "Use \"gui snapshot\" to inspect available trades.\n" +
+        "Selects the trade by index, auto-takes the result into inventory.\n" +
+        "Requires payment items already in inventory.")
+        .requiredOption("--index <index>", "Trade index (0-based)", Number)
+        .action(createRequestAction("craft.trade", ({ options }) => ({ index: options.index })));
+}

package/dist/commands/effects.d.ts

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

package/dist/commands/effects.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createEffectsCommand() {
+    const command = new Command("effects").description("音效与粒子事件");
+    command
+        .command("sounds")
+        .description("获取音效事件")
+        .option("--last <count>", "最近条数", Number)
+        .action(createRequestAction("effects.sounds", ({ options }) => ({ last: options.last ?? 10 })));
+    command
+        .command("particles")
+        .description("获取粒子事件")
+        .option("--last <count>", "最近条数", Number)
+        .action(createRequestAction("effects.particles", ({ options }) => ({ last: options.last ?? 10 })));
+    return command;
+}

package/dist/commands/entity.d.ts

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

package/dist/commands/entity.js

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import { buildEntityFilter, createRequestAction } from "./request-helpers.js";
+export function createEntityCommand() {
+    const command = new Command("entity").description("Entity interaction");
+    const entityActionLabels = {
+        attack: "Attack an entity",
+        interact: "Interact with an entity (right-click)",
+        mount: "Mount an entity"
+    };
+    for (const actionName of ["attack", "interact", "mount"]) {
+        command
+            .command(actionName)
+            .description(entityActionLabels[actionName])
+            .option("--type <type>", "Entity type (e.g. zombie, villager)")
+            .option("--name <name>", "Entity custom name")
+            .option("--nearest", "Target the nearest matching entity")
+            .option("--id <id>", "Entity network ID", Number)
+            .option("--max-distance <distance>", "Max search distance in blocks", Number)
+            .action(createRequestAction(`entity.${actionName}`, ({ options }) => ({
+            filter: buildEntityFilter(options)
+        })));
+    }
+    command
+        .command("list")
+        .description("List nearby entities")
+        .option("--radius <radius>", "Search radius in blocks (default: 10)", Number)
+        .action(createRequestAction("entity.list", ({ options }) => ({ radius: options.radius ?? 10 })));
+    command
+        .command("info")
+        .description("Get detailed entity info")
+        .requiredOption("--id <id>", "Entity network ID", Number)
+        .action(createRequestAction("entity.info", ({ options }) => ({ id: options.id })));
+    command
+        .command("dismount")
+        .description("Dismount from current vehicle")
+        .action(createRequestAction("entity.dismount", () => ({})));
+    command
+        .command("steer")
+        .description("Steer a mounted vehicle (flags can be combined)")
+        .option("--forward", "Move forward")
+        .option("--back", "Move backward")
+        .option("--left", "Turn left")
+        .option("--right", "Turn right")
+        .option("--jump", "Jump")
+        .option("--sneak", "Sneak / dismount")
+        .action(createRequestAction("entity.steer", ({ options }) => ({
+        forward: options.forward ? 1 : options.back ? -1 : 0,
+        sideways: options.left ? 1 : options.right ? -1 : 0,
+        jump: Boolean(options.jump),
+        sneak: Boolean(options.sneak)
+    })));
+    return command;
+}

package/dist/commands/gui.d.ts

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

package/dist/commands/gui.js

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import { createRequestAction, parseNumberList, withTransportTimeoutBuffer } from "./request-helpers.js";
+export function createGuiCommand() {
+    const command = new Command("gui").description("GUI / container interaction (use \"gui snapshot\" to inspect slot indices and contents)");
+    command.command("info").description("Get current GUI info (title, type, slot count)").action(createRequestAction("gui.info", () => ({})));
+    command.command("snapshot").description("Get full GUI snapshot with all slot contents").action(createRequestAction("gui.snapshot", () => ({})));
+    command
+        .command("slot")
+        .description("Get a specific GUI slot")
+        .argument("<slot>", "Slot index")
+        .action(createRequestAction("gui.slot", ({ args }) => ({ slot: Number(args[0]) })));
+    command
+        .command("click")
+        .description("Click a GUI slot")
+        .argument("<slot>", "Slot index")
+        .option("--button <button>", "Click button: left|right|middle|shift-left|shift-right", "left")
+        .option("--key <key>", "Number key 1-9 to quick-move item to that hotbar slot")
+        .action(createRequestAction("gui.click", ({ args, options }) => ({
+        slot: Number(args[0]),
+        button: options.button,
+        key: options.key ? Number(options.key) : undefined
+    })));
+    command
+        .command("drag")
+        .description("Drag across GUI slots (distribute items)")
+        .requiredOption("--slots <slots>", "Comma-separated slot indices, e.g. 1,2,3")
+        .requiredOption("--button <button>", "Drag button: left (split evenly) | right (one each)")
+        .action(createRequestAction("gui.drag", ({ options }) => ({
+        slots: parseNumberList(String(options.slots)),
+        button: options.button
+    })));
+    command.command("close").description("Close the current GUI").action(createRequestAction("gui.close", () => ({})));
+    command
+        .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)));
+    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)));
+    command
+        .command("screenshot")
+        .description("Take a screenshot of the current GUI")
+        .requiredOption("--output <path>", "Output file path")
+        .action(createRequestAction("gui.screenshot", ({ options }) => ({ output: options.output })));
+    return command;
+}

package/dist/commands/hud.d.ts

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

package/dist/commands/hud.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createHudCommand() {
+    const command = new Command("hud").description("HUD element queries");
+    command.command("scoreboard").description("Get sidebar scoreboard").action(createRequestAction("hud.scoreboard", () => ({})));
+    command.command("tab").description("Get tab list (player list)").action(createRequestAction("hud.tab", () => ({})));
+    command.command("bossbar").description("Get boss bar(s)").action(createRequestAction("hud.bossbar", () => ({})));
+    command.command("actionbar").description("Get action bar text").action(createRequestAction("hud.actionbar", () => ({})));
+    command.command("title").description("Get current title/subtitle").action(createRequestAction("hud.title", () => ({})));
+    command
+        .command("nametag")
+        .description("Get a player's nametag info")
+        .requiredOption("--player <player>", "Player name")
+        .action(createRequestAction("hud.nametag", ({ options }) => ({ player: options.player })));
+    return command;
+}

package/dist/commands/input.d.ts

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

package/dist/commands/input.js

@@ -0,0 +1,124 @@
+import { Command } from "commander";
+import { createRequestAction, withTransportTimeoutBuffer } from "./request-helpers.js";
+function buildPointerParams(options) {
+    const modifiers = options.modifiers
+        ? String(options.modifiers)
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean)
+        : [];
+    return {
+        button: options.button ?? "left",
+        modifiers
+    };
+}
+export function createInputCommand() {
+    const command = new Command("input").description("Raw mouse/keyboard input");
+    command
+        .command("click")
+        .description("Click at screen coordinates")
+        .argument("<x>", "Screen X", Number)
+        .argument("<y>", "Screen Y", Number)
+        .option("--button <button>", "Mouse button: left|right|middle", "left")
+        .option("--modifiers <modifiers>", "Modifier keys, comma-separated: shift,ctrl,alt")
+        .action(createRequestAction("input.click", ({ args, options }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        ...buildPointerParams(options)
+    })));
+    command
+        .command("double-click")
+        .description("Double-click at screen coordinates")
+        .argument("<x>", "Screen X", Number)
+        .argument("<y>", "Screen Y", Number)
+        .option("--button <button>", "Mouse button: left|right|middle", "left")
+        .action(createRequestAction("input.double-click", ({ args, options }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        button: options.button ?? "left"
+    })));
+    command
+        .command("mouse-move")
+        .description("Move mouse to screen coordinates")
+        .argument("<x>", "Screen X", Number)
+        .argument("<y>", "Screen Y", Number)
+        .action(createRequestAction("input.mouse-move", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1])
+    })));
+    command
+        .command("drag")
+        .description("Mouse drag from one position to another")
+        .argument("<fromX>", "Start X", Number)
+        .argument("<fromY>", "Start Y", Number)
+        .argument("<toX>", "End X", Number)
+        .argument("<toY>", "End Y", Number)
+        .option("--button <button>", "Mouse button: left|right|middle", "left")
+        .action(createRequestAction("input.drag", ({ args, options }) => ({
+        fromX: Number(args[0]),
+        fromY: Number(args[1]),
+        toX: Number(args[2]),
+        toY: Number(args[3]),
+        button: options.button ?? "left"
+    })));
+    command
+        .command("scroll")
+        .description("Scroll mouse wheel at coordinates")
+        .argument("<x>", "Screen X", Number)
+        .argument("<y>", "Screen Y", Number)
+        .requiredOption("--delta <delta>", "Scroll amount (positive = up, negative = down)", Number)
+        .action(createRequestAction("input.scroll", ({ args, options }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        delta: Number(options.delta)
+    })));
+    const keyCommand = command.command("key").description("Keyboard input");
+    keyCommand
+        .command("press")
+        .description("Press and release a key")
+        .argument("<key>", "Key name (e.g. w, a, s, d, space, escape, shift, enter, tab, e, f1)")
+        .action(createRequestAction("input.key-press", ({ args }) => ({ key: String(args[0]) })));
+    keyCommand
+        .command("hold")
+        .description("Hold a key for a duration")
+        .argument("<key>", "Key name")
+        .requiredOption("--duration <ms>", "Hold duration in milliseconds", Number)
+        .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)));
+    keyCommand
+        .command("down")
+        .description("Press a key down (without releasing)")
+        .argument("<key>", "Key name")
+        .action(createRequestAction("input.key-down", ({ args }) => ({ key: String(args[0]) })));
+    keyCommand
+        .command("up")
+        .description("Release a key")
+        .argument("<key>", "Key name")
+        .action(createRequestAction("input.key-up", ({ args }) => ({ key: String(args[0]) })));
+    keyCommand
+        .command("combo")
+        .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)
+    })));
+    command
+        .command("type")
+        .description("Type text into the currently focused field")
+        .argument("<text>", "Text to type")
+        .action(createRequestAction("input.type", ({ args }) => ({ text: String(args[0]) })));
+    command
+        .command("mouse-pos")
+        .description("Get current mouse position")
+        .action(createRequestAction("input.mouse-pos", () => ({})));
+    command
+        .command("keys-down")
+        .description("Get currently held keys")
+        .action(createRequestAction("input.keys-down", () => ({})));
+    return command;
+}

package/dist/commands/inventory.d.ts

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

package/dist/commands/inventory.js

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createInventoryCommand() {
+    const command = new Command("inventory").description("Inventory and item operations");
+    command.command("get").description("Get full inventory contents").action(createRequestAction("inventory.get", () => ({})));
+    command
+        .command("slot")
+        .description("Get a specific inventory slot")
+        .argument("<slot>", "Slot index (0-8: hotbar, 9-35: main inventory)")
+        .action(createRequestAction("inventory.slot", ({ args }) => ({ slot: Number(args[0]) })));
+    command.command("held").description("Get currently held item").action(createRequestAction("inventory.held", () => ({})));
+    command
+        .command("hotbar")
+        .description("Switch active hotbar slot")
+        .argument("<slot>", "Hotbar slot (0-8)")
+        .action(createRequestAction("inventory.hotbar", ({ args }) => ({ slot: Number(args[0]) })));
+    command
+        .command("drop")
+        .description("Drop the held item")
+        .option("--all", "Drop the entire stack")
+        .action(createRequestAction("inventory.drop", ({ options }) => ({ all: Boolean(options.all) })));
+    command.command("use").description("Use (right-click) the held item").action(createRequestAction("inventory.use", () => ({})));
+    command
+        .command("swap-hands")
+        .description("Swap main hand and off-hand items")
+        .action(createRequestAction("inventory.swap-hands", () => ({})));
+    return command;
+}

package/dist/commands/look.d.ts

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

package/dist/commands/look.js

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import { buildEntityFilter, createRequestAction } from "./request-helpers.js";
+export function createLookCommand() {
+    const command = new Command("look").description("Camera / view direction control");
+    command
+        .command("at")
+        .description("Look at coordinates")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .action(createRequestAction("look.at", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2])
+    })));
+    command
+        .command("entity")
+        .description("Look at an entity")
+        .option("--type <type>", "Entity type (e.g. zombie, villager)")
+        .option("--name <name>", "Entity custom name")
+        .option("--nearest", "Target the nearest matching entity")
+        .option("--id <id>", "Entity network ID", Number)
+        .option("--max-distance <distance>", "Max search distance in blocks", Number)
+        .action(createRequestAction("look.entity", ({ options }) => ({
+        filter: buildEntityFilter(options)
+    })));
+    command
+        .command("set")
+        .description("Set camera angle directly")
+        .requiredOption("--yaw <yaw>", "Horizontal angle (-180 to 180: 0=south, -90=east, 90=west, ±180=north)", Number)
+        .requiredOption("--pitch <pitch>", "Vertical angle (-90=up, 0=horizon, 90=down)", Number)
+        .action(createRequestAction("look.set", ({ options }) => ({
+        yaw: options.yaw,
+        pitch: options.pitch
+    })));
+    return command;
+}

package/dist/commands/move.d.ts

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

package/dist/commands/move.js

@@ -0,0 +1,50 @@
+import { Command } from "commander";
+import { createRequestAction, withTransportTimeoutBuffer } from "./request-helpers.js";
+export function createMoveCommand() {
+    const command = new Command("move").description("Movement control");
+    command
+        .command("to")
+        .description("Move to coordinates (straight-line walk, may get stuck on obstacles; times out after 30s)")
+        .argument("<x>", "X coordinate")
+        .argument("<y>", "Y coordinate")
+        .argument("<z>", "Z coordinate")
+        .action(createRequestAction("move.to", ({ args }) => ({
+        x: Number(args[0]),
+        y: Number(args[1]),
+        z: Number(args[2])
+    }), (_payload, context) => withTransportTimeoutBuffer(30, context.config.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
+            .command(direction)
+            .description(directionLabels[direction])
+            .argument("<blocks>", "Distance in blocks (supports decimals)")
+            .action(createRequestAction("move.direction", ({ args }) => ({
+            direction,
+            blocks: Number(args[0])
+        }), ({ 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);
+        }));
+    }
+    command
+        .command("jump")
+        .description("Jump once")
+        .action(createRequestAction("move.jump", () => ({})));
+    command
+        .command("sneak")
+        .description("Toggle sneaking")
+        .argument("<state>", "on/off")
+        .action(createRequestAction("move.sneak", ({ args }) => ({
+        enabled: args[0] === "on"
+    })));
+    command
+        .command("sprint")
+        .description("Toggle sprinting")
+        .argument("<state>", "on/off")
+        .action(createRequestAction("move.sprint", ({ args }) => ({
+        enabled: args[0] === "on"
+    })));
+    return command;
+}

package/dist/commands/position.d.ts

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

package/dist/commands/position.js

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { createRequestAction } from "./request-helpers.js";
+export function createPositionCommand() {
+    const command = new Command("position").description("Position query");
+    command.command("get").description("Get current player position (x, y, z)").action(createRequestAction("position.get", () => ({})));
+    return command;
+}