mesen_handlers.h

Go to the documentation of this file.

#ifndef YAZE_CLI_HANDLERS_MESEN_HANDLERS_H_
#define YAZE_CLI_HANDLERS_MESEN_HANDLERS_H_
 
#include <string>
#include <vector>
 
#include "cli/service/resources/command_handler.h"
 
namespace yaze {
namespace cli {
namespace handlers {
 
// Handler implementations for Mesen2 commands
 
class MesenGamestateCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-gamestate"; }
  std::string GetDescription() const {
    return "Get ALTTP game state from running Mesen2";
  }
  std::string GetUsage() const override {
    return "mesen-gamestate [--format <json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenSpritesCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-sprites"; }
  std::string GetDescription() const {
    return "Get active sprites from running Mesen2";
  }
  std::string GetUsage() const override {
    return "mesen-sprites [--all] [--format <json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenCpuCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-cpu"; }
  std::string GetDescription() const {
    return "Get CPU register state from Mesen2";
  }
  std::string GetUsage() const override {
    return "mesen-cpu [--format <json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenMemoryReadCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-memory-read"; }
  std::string GetDescription() const {
    return "Read memory from Mesen2 emulator";
  }
  std::string GetUsage() const override {
    return "mesen-memory-read --address <hex> [--length <n>] [--format "
           "<json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenMemoryWriteCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-memory-write"; }
  std::string GetDescription() const {
    return "Write memory in Mesen2 emulator";
  }
  std::string GetUsage() const override {
    return "mesen-memory-write --address <hex> --data <hexbytes> [--format "
           "<json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenDisasmCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-disasm"; }
  std::string GetDescription() const {
    return "Disassemble code at address in Mesen2";
  }
  std::string GetUsage() const override {
    return "mesen-disasm --address <hex> [--count <n>] [--format <json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenTraceCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-trace"; }
  std::string GetDescription() const {
    return "Get execution trace from Mesen2";
  }
  std::string GetUsage() const override {
    return "mesen-trace [--count <n>] [--format <json|text>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenBreakpointCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-breakpoint"; }
  std::string GetDescription() const { return "Manage breakpoints in Mesen2"; }
  std::string GetUsage() const override {
    return "mesen-breakpoint --action <add|remove|clear|list> [--address "
           "<hex>] [--id <n>] [--type <exec|read|write|rw>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenControlCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-control"; }
  std::string GetDescription() const {
    return "Control Mesen2 emulation state";
  }
  std::string GetUsage() const override {
    return "mesen-control --action <pause|resume|step|frame|reset>";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenSessionCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-session"; }
  std::string GetDescription() const {
    return "Get tracked autonomous control session state";
  }
  std::string GetUsage() const override {
    return "mesen-session [--action <show|reset|export|import>] [--file "
           "<path>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenAwaitCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-await"; }
  std::string GetDescription() const {
    return "Block until frame/pc/breakpoint condition is met";
  }
  std::string GetUsage() const override {
    return "mesen-await --type <frame|pc|breakpoint> [--count <n>] [--address "
           "<hex>] [--id <n>] [--timeout-ms <n>] [--poll-ms <n>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenGoalCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-goal"; }
  std::string GetDescription() const {
    return "Execute atomic goal macros for deterministic debugging";
  }
  std::string GetUsage() const override {
    return "mesen-goal --goal <break-at|run-frames|capture-state-at-pc> "
           "[--address <hex>] [--count <n>] [--timeout-ms <n>] [--poll-ms <n>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenStateVerifyCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-state-verify"; }
  std::string GetDescription() const {
    return "Verify a savestate matches current ROM hash and metadata";
  }
  std::string GetUsage() const override {
    return "mesen-state-verify --state <path> --rom-file <path> [--meta "
           "<path>] "
           "[--scenario <id>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenStateRegenCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-state-regen"; }
  std::string GetDescription() const {
    return "Regenerate savestate freshness metadata for current ROM";
  }
  std::string GetUsage() const override {
    return "mesen-state-regen --state <path> --rom-file <path> [--meta <path>] "
           "[--scenario <id>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenStateCaptureCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-state-capture"; }
  std::string GetDescription() const {
    return "Capture/refresh savestate metadata in one command";
  }
  std::string GetUsage() const override {
    return "mesen-state-capture --state <path> --rom-file <path> [--meta "
           "<path>] [--scenario <id>] [--slot <n>] [--states-dir <path>] "
           "[--wait-ms <n>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
class MesenStateHookCommandHandler : public resources::CommandHandler {
 public:
  std::string GetName() const override { return "mesen-state-hook"; }
  std::string GetDescription() const {
    return "Preflight hook summary for agent automation";
  }
  std::string GetUsage() const override {
    return "mesen-state-hook --state <path> --rom-file <path> [--meta "
           "<path>] [--scenario <id>]";
  }
  bool RequiresRom() const override { return false; }
  absl::Status ValidateArgs(const resources::ArgumentParser& parser) override;
  absl::Status Execute(Rom* rom, const resources::ArgumentParser& parser,
                       resources::OutputFormatter& formatter) override;
};
 
std::vector<std::unique_ptr<resources::CommandHandler>>
CreateMesenCommandHandlers();
 
}  // namespace handlers
}  // namespace cli
}  // namespace yaze
 
#endif  // YAZE_CLI_HANDLERS_MESEN_HANDLERS_H_