scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

imgui-frontend-engineer: refactor gRPC agent services

Browse Source
This commit is contained in:
scawful
2025-12-28 10:52:15 -06:00
parent a65fc1d975
commit 954c612f69
15 changed files with 620 additions and 1305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/app/net/net_library.cmake
View File

@@ -101,7 +101,7 @@ if(YAZE_ENABLE_JSON)
# CRITICAL FIX: Disable OpenSSL on Windows to avoid missing header errors
# Windows CI doesn't have OpenSSL headers properly configured
# WebSocket will work with plain HTTP (no SSL/TLS) on Windows
if(NOT WIN32)
if(NOT WIN32 AND NOT YAZE_PLATFORM_IOS)
find_package(OpenSSL QUIET)
if(OPENSSL_INCLUDE_DIR)
target_include_directories(yaze_net PUBLIC ${OPENSSL_INCLUDE_DIR})
@@ -120,16 +120,16 @@ if(YAZE_ENABLE_JSON)
message(STATUS " - WebSocket without SSL/TLS (OpenSSL not found)")
endif()
else()
message(STATUS " - Windows: WebSocket using plain HTTP (no SSL) - OpenSSL headers not available in CI")
message(STATUS " - OpenSSL disabled on Windows/iOS (plain HTTP only)")
endif()
else()
# When gRPC is enabled, still enable OpenSSL features but use gRPC's OpenSSL
# CRITICAL: Skip on Windows - gRPC's OpenSSL headers aren't accessible in Windows CI
if(NOT WIN32)
if(NOT WIN32 AND NOT YAZE_PLATFORM_IOS)
target_compile_definitions(yaze_net PUBLIC CPPHTTPLIB_OPENSSL_SUPPORT)
message(STATUS " - WebSocket with SSL/TLS support enabled via gRPC's OpenSSL")
else()
message(STATUS " - Windows + gRPC: WebSocket using plain HTTP (no SSL) - OpenSSL headers not available")
message(STATUS " - Windows/iOS + gRPC: WebSocket using plain HTTP (no SSL)")
endif()
endif()

2
src/app/net/websocket_client.cc
View File

@@ -10,7 +10,7 @@
// Cross-platform WebSocket support using httplib
// Skip httplib in WASM builds - use Emscripten WebSocket API instead
#if defined(YAZE_WITH_JSON) && !defined(__EMSCRIPTEN__)
#ifndef _WIN32
#if !defined(_WIN32) && !defined(YAZE_IOS)
#define CPPHTTPLIB_OPENSSL_SUPPORT
#endif
#include "httplib.h"

9
src/app/service/grpc_support.cmake
View File

@@ -47,11 +47,6 @@ target_include_directories(yaze_grpc_support PUBLIC
target_link_libraries(yaze_grpc_support PUBLIC
yaze_util
yaze_common
yaze_zelda3
yaze_gfx
yaze_gui
yaze_emulator
yaze_net
${ABSL_TARGETS}
${YAZE_SDL2_TARGETS}
)
@@ -114,8 +109,10 @@ set_target_properties(yaze_grpc_support PROPERTIES
# Platform-specific compile definitions
if(UNIX AND NOT APPLE)
target_compile_definitions(yaze_grpc_support PRIVATE linux stricmp=strcasecmp)
elseif(APPLE)
elseif(YAZE_PLATFORM_MACOS)
target_compile_definitions(yaze_grpc_support PRIVATE MACOS)
elseif(YAZE_PLATFORM_IOS)
target_compile_definitions(yaze_grpc_support PRIVATE YAZE_IOS)
elseif(WIN32)
target_compile_definitions(yaze_grpc_support PRIVATE WINDOWS)
endif()

160
src/app/service/rom_service_impl.cc
View File

@@ -13,9 +13,9 @@ namespace yaze {
namespace net {
RomServiceImpl::RomServiceImpl(Rom* rom, RomVersionManager* version_manager,
RomServiceImpl::RomServiceImpl(RomGetter rom_getter, RomVersionManager* version_manager,
ProposalApprovalManager* approval_manager)
: rom_(rom),
: rom_getter_(rom_getter),
version_mgr_(version_manager),
approval_mgr_(approval_manager) {}
@@ -26,7 +26,8 @@ void RomServiceImpl::SetConfig(const Config& config) {
grpc::Status RomServiceImpl::ReadBytes(grpc::ServerContext* context,
const rom_svc::ReadBytesRequest* request,
rom_svc::ReadBytesResponse* response) {
if (!rom_ || !rom_->is_loaded()) {
Rom* rom = rom_getter_();
if (!rom || !rom->is_loaded()) {
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION,
"ROM not loaded");
}
@@ -35,23 +36,24 @@ grpc::Status RomServiceImpl::ReadBytes(grpc::ServerContext* context,
uint32_t length = request->length();
// Validate range
if (offset + length > rom_->size()) {
if (offset + length > rom->size()) {
return grpc::Status(grpc::StatusCode::OUT_OF_RANGE,
absl::StrFormat("Read beyond ROM: 0x%X+%d > %d",
offset, length, rom_->size()));
offset, length, rom->size()));
}
// Read data
const auto* data = rom_->data() + offset;
const auto* data = rom->data() + offset;
response->set_data(data, length);
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::WriteBytes(
grpc::ServerContext* context, const rom_svc::WriteBytesRequest* request,
rom_svc::WriteBytesResponse* response) {
if (!rom_ || !rom_->is_loaded()) {
grpc::Status RomServiceImpl::WriteBytes(grpc::ServerContext* context,
const rom_svc::WriteBytesRequest* request,
rom_svc::WriteBytesResponse* response) {
Rom* rom = rom_getter_();
if (!rom || !rom->is_loaded()) {
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION,
"ROM not loaded");
}
@@ -60,118 +62,74 @@ grpc::Status RomServiceImpl::WriteBytes(
const std::string& data = request->data();
// Validate range
if (offset + data.size() > rom_->size()) {
if (offset + data.size() > rom->size()) {
return grpc::Status(grpc::StatusCode::OUT_OF_RANGE,
absl::StrFormat("Write beyond ROM: 0x%X+%zu > %d",
offset, data.size(), rom_->size()));
offset, data.size(), rom->size()));
}
// Check if approval required
if (config_.require_approval_for_writes && approval_mgr_) {
// Create a proposal for this write
std::string proposal_id =
absl::StrFormat("write_0x%X_%zu_bytes", offset, data.size());
// Check if proposal is approved
if (!approval_mgr_->IsProposalApproved(proposal_id)) {
response->set_success(false);
response->set_error("Write requires approval");
response->set_proposal_id(proposal_id);
return grpc::Status::OK; // Not an error, just needs approval
}
if (config_.require_approval_for_writes) {
return grpc::Status(grpc::StatusCode::PERMISSION_DENIED,
"Direct ROM writes disabled; use proposal system");
}
// Create snapshot before write
if (version_mgr_) {
std::string snapshot_desc = absl::StrFormat(
"Before write to 0x%X (%zu bytes)", offset, data.size());
// Creator is "system" for now, could be passed in context
version_mgr_->CreateSnapshot(snapshot_desc, "system");
// Create auto-snapshot if enabled
auto status = MaybeCreateSnapshot(absl::StrFormat(
"Auto-snapshot before write at 0x%X (%zu bytes)", offset, data.size()));
if (!status.ok()) {
return grpc::Status(grpc::StatusCode::INTERNAL,
"Failed to create safety snapshot: " +
std::string(status.message()));
}
// Perform write
std::memcpy(rom_->mutable_data() + offset, data.data(), data.size());
// Perform the write
std::memcpy(rom->mutable_data() + offset, data.data(), data.size());
response->set_success(true);
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::GetRomInfo(
grpc::ServerContext* context, const rom_svc::GetRomInfoRequest* request,
rom_svc::GetRomInfoResponse* response) {
if (!rom_ || !rom_->is_loaded()) {
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION,
"ROM not loaded");
grpc::Status RomServiceImpl::GetRomInfo(grpc::ServerContext* context,
const rom_svc::GetRomInfoRequest* request,
rom_svc::GetRomInfoResponse* response) {
Rom* rom = rom_getter_();
if (!rom || !rom->is_loaded()) {
response->set_title("ROM not loaded");
return grpc::Status::OK;
}
response->set_title(rom_->title());
response->set_size(rom_->size());
// response->set_is_loaded(rom_->is_loaded()); // Not in proto
// response->set_filename(rom_->filename()); // Not in proto
// Proto has: title, size, checksum, is_expanded, version
response->set_title(rom->title());
response->set_size(rom->size());
// Removed checksum, is_expanded, version as they don't exist in yaze::Rom
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::ReadOverworldMap(
grpc::ServerContext* context, const rom_svc::ReadOverworldMapRequest* request,
rom_svc::ReadOverworldMapResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
// ... Stubs for other methods to keep it building ...
grpc::Status RomServiceImpl::ReadOverworldMap(grpc::ServerContext* context, const rom_svc::ReadOverworldMapRequest* request, rom_svc::ReadOverworldMapResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::WriteOverworldTile(grpc::ServerContext* context, const rom_svc::WriteOverworldTileRequest* request, rom_svc::WriteOverworldTileResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::ReadDungeonRoom(grpc::ServerContext* context, const rom_svc::ReadDungeonRoomRequest* request, rom_svc::ReadDungeonRoomResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::WriteDungeonTile(grpc::ServerContext* context, const rom_svc::WriteDungeonTileRequest* request, rom_svc::WriteDungeonTileResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::ReadSprite(grpc::ServerContext* context, const rom_svc::ReadSpriteRequest* request, rom_svc::ReadSpriteResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::SubmitRomProposal(grpc::ServerContext* context, const rom_svc::SubmitRomProposalRequest* request, rom_svc::SubmitRomProposalResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::GetProposalStatus(grpc::ServerContext* context, const rom_svc::GetProposalStatusRequest* request, rom_svc::GetProposalStatusResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::CreateSnapshot(grpc::ServerContext* context, const rom_svc::CreateSnapshotRequest* request, rom_svc::CreateSnapshotResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::RestoreSnapshot(grpc::ServerContext* context, const rom_svc::RestoreSnapshotRequest* request, rom_svc::RestoreSnapshotResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::ListSnapshots(grpc::ServerContext* context, const rom_svc::ListSnapshotsRequest* request, rom_svc::ListSnapshotsResponse* response) { return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented"); }
grpc::Status RomServiceImpl::ValidateRomLoaded() {
Rom* rom = rom_getter_();
if (!rom || !rom->is_loaded()) {
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "ROM not loaded");
}
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::ReadDungeonRoom(
grpc::ServerContext* context, const rom_svc::ReadDungeonRoomRequest* request,
rom_svc::ReadDungeonRoomResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::ReadSprite(
grpc::ServerContext* context, const rom_svc::ReadSpriteRequest* request,
rom_svc::ReadSpriteResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::WriteOverworldTile(
grpc::ServerContext* context, const rom_svc::WriteOverworldTileRequest* request,
rom_svc::WriteOverworldTileResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::WriteDungeonTile(
grpc::ServerContext* context, const rom_svc::WriteDungeonTileRequest* request,
rom_svc::WriteDungeonTileResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::SubmitRomProposal(
grpc::ServerContext* context, const rom_svc::SubmitRomProposalRequest* request,
rom_svc::SubmitRomProposalResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::GetProposalStatus(
grpc::ServerContext* context, const rom_svc::GetProposalStatusRequest* request,
rom_svc::GetProposalStatusResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::CreateSnapshot(
grpc::ServerContext* context, const rom_svc::CreateSnapshotRequest* request,
rom_svc::CreateSnapshotResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::RestoreSnapshot(
grpc::ServerContext* context, const rom_svc::RestoreSnapshotRequest* request,
rom_svc::RestoreSnapshotResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
}
grpc::Status RomServiceImpl::ListSnapshots(
grpc::ServerContext* context, const rom_svc::ListSnapshotsRequest* request,
rom_svc::ListSnapshotsResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "Not implemented");
absl::Status RomServiceImpl::MaybeCreateSnapshot(const std::string& description) {
if (!config_.enable_version_management || !version_mgr_) {
return absl::OkStatus();
}
return version_mgr_->CreateSnapshot(description, "gRPC", false).status();
}
} // namespace net

28
src/app/service/rom_service_impl.h
View File

@@ -24,6 +24,7 @@
// Note: Proto files will be generated to build directory
#endif
#include <functional>
#include "app/net/rom_version_manager.h"
#include "rom/rom.h"
@@ -35,34 +36,25 @@ namespace net {
/**
* @brief gRPC service implementation for remote ROM manipulation
*
* Enables remote clients (like z3ed CLI) to:
* - Read/write ROM data
* - Submit proposals for collaborative editing
* - Manage ROM versions and snapshots
* - Query ROM structures (overworld, dungeons, sprites)
*
* Thread-safe and designed for concurrent access.
*/
class RomServiceImpl final : public proto::RomService::Service {
public:
/**
* @brief Configuration for the ROM service
*/
using RomGetter = std::function<Rom*()>;
struct Config {
bool require_approval_for_writes = true; // Submit writes as proposals
bool enable_version_management = true; // Auto-snapshot before changes
int max_read_size_bytes = 1024 * 1024; // 1MB max per read
bool allow_raw_rom_access = true; // Allow direct byte access
bool require_approval_for_writes = true;
bool enable_version_management = true;
int max_read_size_bytes = 1024 * 1024;
bool allow_raw_rom_access = true;
};
/**
* @brief Construct ROM service
* @param rom Pointer to ROM instance (not owned)
* @param rom_getter Function to retrieve the active ROM instance
* @param version_mgr Pointer to version manager (not owned, optional)
* @param approval_mgr Pointer to approval manager (not owned, optional)
*/
RomServiceImpl(Rom* rom, RomVersionManager* version_mgr = nullptr,
RomServiceImpl(RomGetter rom_getter, RomVersionManager* version_mgr = nullptr,
ProposalApprovalManager* approval_mgr = nullptr);
~RomServiceImpl() override = default;
@@ -155,7 +147,7 @@ class RomServiceImpl final : public proto::RomService::Service {
private:
Config config_;
Rom* rom_; // Not owned
RomGetter rom_getter_;
RomVersionManager* version_mgr_; // Not owned, may be null
ProposalApprovalManager* approval_mgr_; // Not owned, may be null

31
src/app/service/unified_grpc_server.cc
View File

@@ -14,17 +14,19 @@
#include "app/service/imgui_test_harness_service.h"
#include "protos/canvas_automation.grpc.pb.h"
#include "app/editor/editor_manager.h"
namespace yaze {
YazeGRPCServer::YazeGRPCServer() : is_running_(false) {}
// Destructor defined here so CanvasAutomationServiceGrpc is a complete type
YazeGRPCServer::~YazeGRPCServer() {
Shutdown();
}
absl::Status YazeGRPCServer::Initialize(
int port, test::TestManager* test_manager, Rom* rom,
int port, test::TestManager* test_manager,
RomGetter rom_getter,
net::RomVersionManager* version_mgr,
net::ProposalApprovalManager* approval_mgr,
CanvasAutomationServiceImpl* canvas_service) {
@@ -39,14 +41,12 @@ absl::Status YazeGRPCServer::Initialize(
test_harness_service_ =
std::make_unique<test::ImGuiTestHarnessServiceImpl>(test_manager);
std::cout << "✓ ImGuiTestHarness service initialized\n";
} else if (config_.enable_test_harness) {
std::cout << "⚠ ImGuiTestHarness requested but no TestManager provided\n";
}
// Create ROM service if rom provided
if (config_.enable_rom_service && rom) {
// Create ROM service if rom_getter provided
if (config_.enable_rom_service && rom_getter) {
rom_service_ =
std::make_unique<net::RomServiceImpl>(rom, version_mgr, approval_mgr);
std::make_unique<net::RomServiceImpl>(rom_getter, version_mgr, approval_mgr);
// Configure ROM service
net::RomServiceImpl::Config rom_config;
@@ -115,6 +115,19 @@ absl::Status YazeGRPCServer::StartAsync() {
return absl::OkStatus();
}
absl::Status YazeGRPCServer::AddService(
std::unique_ptr<grpc::Service> service) {
if (!service) {
return absl::InvalidArgumentError("Service is null");
}
if (is_running_) {
return absl::FailedPreconditionError(
"Cannot add services after the server has started");
}
extra_services_.push_back(std::move(service));
return absl::OkStatus();
}
void YazeGRPCServer::Shutdown() {
if (server_ && is_running_) {
std::cout << "⏹ Shutting down unified gRPC server...\n";
@@ -163,6 +176,10 @@ absl::Status YazeGRPCServer::BuildServer() {
builder.RegisterService(canvas_grpc_service_.get());
}
for (auto& service : extra_services_) {
builder.RegisterService(service.get());
}
// Build and start
server_ = builder.BuildAndStart();

85
src/app/service/unified_grpc_server.h
View File

@@ -4,6 +4,8 @@
#ifdef YAZE_WITH_GRPC
#include <memory>
#include <vector>
#include <functional>
#include "absl/status/status.h"
#include "app/net/rom_version_manager.h"
@@ -19,8 +21,12 @@ namespace yaze {
// Forward declarations
class CanvasAutomationServiceImpl;
class Rom;
namespace editor {
class EditorManager;
}
namespace net {
class ProposalApprovalManager;
class RomServiceImpl;
@@ -34,31 +40,11 @@ class ImGuiTestHarnessServiceImpl;
/**
* @class YazeGRPCServer
* @brief YAZE's unified gRPC server for Zelda3 editor automation
*
* This server combines multiple automation services for the Zelda editor:
* 1. ImGuiTestHarness - GUI test automation (widget discovery, screenshots,
* etc.)
* 2. RomService - ROM manipulation (read/write, proposals, version management)
* 3. CanvasAutomation - Canvas operations (tiles, selection, zoom, pan)
*
* All services share the same gRPC server instance and port, allowing
* clients (CLI, AI agents, remote scripts) to interact with GUI, ROM data,
* and canvas operations simultaneously.
*
* Example usage:
* ```cpp
* YazeGRPCServer server;
* server.Initialize(50051, test_manager, rom, version_mgr, approval_mgr,
* canvas_service); server.Start();
* // ... do work ...
* server.Shutdown();
* ```
*/
class YazeGRPCServer {
public:
/**
* @brief Configuration for the unified server
*/
using RomGetter = std::function<Rom*()>;
struct Config {
int port = 50051;
bool enable_test_harness = true;
@@ -68,56 +54,31 @@ class YazeGRPCServer {
};
YazeGRPCServer();
// Destructor must be defined in .cc file to allow deletion of incomplete
// types
~YazeGRPCServer();
/**
* @brief Initialize the server with all required services
* @param port Port to listen on (default 50051)
* @param test_manager TestManager for GUI automation (optional)
* @param rom ROM instance for ROM service (optional)
* @param version_mgr Version manager for ROM snapshots (optional)
* @param approval_mgr Approval manager for proposals (optional)
* @param canvas_service Canvas automation service implementation (optional)
* @param port Port to listen on
* @param test_manager TestManager for GUI automation
* @param rom_getter Function to retrieve active ROM
* @param version_mgr Version manager for ROM snapshots
* @param approval_mgr Approval manager for proposals
* @param canvas_service Canvas automation service implementation
* @return OK status if initialized successfully
*/
absl::Status Initialize(
int port, test::TestManager* test_manager = nullptr, Rom* rom = nullptr,
int port, test::TestManager* test_manager = nullptr,
RomGetter rom_getter = nullptr,
net::RomVersionManager* version_mgr = nullptr,
net::ProposalApprovalManager* approval_mgr = nullptr,
CanvasAutomationServiceImpl* canvas_service = nullptr);
/**
* @brief Start the gRPC server (blocking)
* Starts the server and blocks until Shutdown() is called
*/
absl::Status Start();
/**
* @brief Start the server in a background thread (non-blocking)
* Returns immediately after starting the server
*/
absl::Status StartAsync();
/**
* @brief Shutdown the server gracefully
*/
absl::Status AddService(std::unique_ptr<grpc::Service> service);
void Shutdown();
/**
* @brief Check if server is currently running
*/
bool IsRunning() const;
/**
* @brief Get the port the server is listening on
*/
int Port() const { return config_.port; }
/**
* @brief Update configuration (must be called before Start)
*/
void SetConfig(const Config& config) { config_ = config; }
private:
@@ -126,12 +87,11 @@ class YazeGRPCServer {
std::unique_ptr<test::ImGuiTestHarnessServiceImpl> test_harness_service_;
std::unique_ptr<net::RomServiceImpl> rom_service_;
CanvasAutomationServiceImpl* canvas_service_ = nullptr;
// Store as base grpc::Service* to avoid incomplete type issues
std::unique_ptr<grpc::Service> canvas_grpc_service_;
std::unique_ptr<grpc::Service> test_harness_grpc_wrapper_;
std::vector<std::unique_ptr<grpc::Service>> extra_services_;
bool is_running_;
// Build the gRPC server with all services
absl::Status BuildServer();
};
@@ -139,10 +99,3 @@ class YazeGRPCServer {
#endif // YAZE_WITH_GRPC
#endif // YAZE_APP_CORE_SERVICE_UNIFIED_GRPC_SERVER_H_
// Backwards compatibility alias
#ifdef YAZE_WITH_GRPC
namespace yaze {
using UnifiedGRPCServer = YazeGRPCServer;
}
#endif

2
src/cli/agent.cmake
View File

@@ -238,7 +238,7 @@ if(YAZE_ENABLE_REMOTE_AUTOMATION)
list(APPEND YAZE_AGENT_SOURCES
cli/service/agent/agent_control_server.cc
cli/service/agent/emulator_service_impl.cc
cli/handlers/tools/emulator_commands.cc
cli/service/agent/rom_debug_agent.cc
cli/service/gui/gui_automation_client.cc
cli/service/gui/canvas_automation_client.cc
)

2
src/cli/service/agent/agent_control_server.cc
View File

@@ -31,7 +31,7 @@ void AgentControlServer::Stop() {
void AgentControlServer::Run() {
std::string server_address("0.0.0.0:50051");
EmulatorServiceImpl service(emulator_);
yaze::net::EmulatorServiceImpl service(emulator_, nullptr);
grpc::ServerBuilder builder;
builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());

1101
src/cli/service/agent/emulator_service_impl.cc
View File

File diff suppressed because it is too large Load Diff

165
src/cli/service/agent/emulator_service_impl.h
View File

@@ -1,133 +1,100 @@
#pragma once
#include <grpcpp/grpcpp.h>
#include <memory>
#include "app/emu/debug/step_controller.h"
#include "app/emu/debug/symbol_provider.h"
#include "protos/emulator_service.grpc.pb.h"
// Forward declaration to avoid circular dependencies
namespace yaze::emu {
namespace yaze {
class Rom;
namespace emu {
class Emulator;
}
}
namespace yaze::agent {
namespace yaze::net {
class EmulatorServiceImpl final : public EmulatorService::Service {
class EmulatorServiceImpl final : public agent::EmulatorService::Service {
public:
explicit EmulatorServiceImpl(yaze::emu::Emulator* emulator);
using RomGetter = std::function<Rom*()>;
explicit EmulatorServiceImpl(yaze::emu::Emulator* emulator, RomGetter rom_getter = nullptr);
// --- Lifecycle ---
grpc::Status Start(grpc::ServerContext* context, const Empty* request,
CommandResponse* response) override;
grpc::Status Stop(grpc::ServerContext* context, const Empty* request,
CommandResponse* response) override;
grpc::Status Pause(grpc::ServerContext* context, const Empty* request,
CommandResponse* response) override;
grpc::Status Resume(grpc::ServerContext* context, const Empty* request,
CommandResponse* response) override;
grpc::Status Reset(grpc::ServerContext* context, const Empty* request,
CommandResponse* response) override;
// --- Core Lifecycle & Control ---
grpc::Status ControlEmulator(grpc::ServerContext* context,
const agent::ControlRequest* request,
agent::CommandResponse* response) override;
// --- Input Control ---
grpc::Status PressButtons(grpc::ServerContext* context,
const ButtonRequest* request,
CommandResponse* response) override;
grpc::Status ReleaseButtons(grpc::ServerContext* context,
const ButtonRequest* request,
CommandResponse* response) override;
grpc::Status HoldButtons(grpc::ServerContext* context,
const ButtonHoldRequest* request,
CommandResponse* response) override;
grpc::Status StepEmulator(grpc::ServerContext* context,
const agent::StepControlRequest* request,
agent::StepResponse* response) override;
// --- State Inspection ---
grpc::Status GetGameState(grpc::ServerContext* context,
const GameStateRequest* request,
GameStateResponse* response) override;
grpc::Status ReadMemory(grpc::ServerContext* context,
const MemoryRequest* request,
MemoryResponse* response) override;
grpc::Status WriteMemory(grpc::ServerContext* context,
const MemoryWriteRequest* request,
CommandResponse* response) override;
// --- Advanced Debugging ---
// Breakpoints
grpc::Status AddBreakpoint(grpc::ServerContext* context,
const BreakpointRequest* request,
BreakpointResponse* response) override;
grpc::Status RemoveBreakpoint(grpc::ServerContext* context,
const BreakpointIdRequest* request,
CommandResponse* response) override;
grpc::Status ListBreakpoints(grpc::ServerContext* context,
const Empty* request,
BreakpointListResponse* response) override;
grpc::Status SetBreakpointEnabled(grpc::ServerContext* context,
const BreakpointStateRequest* request,
CommandResponse* response) override;
// Watchpoints (memory access tracking)
grpc::Status AddWatchpoint(grpc::ServerContext* context,
const WatchpointRequest* request,
WatchpointResponse* response) override;
grpc::Status RemoveWatchpoint(grpc::ServerContext* context,
const WatchpointIdRequest* request,
CommandResponse* response) override;
grpc::Status ListWatchpoints(grpc::ServerContext* context,
const Empty* request,
WatchpointListResponse* response) override;
grpc::Status GetWatchpointHistory(
grpc::ServerContext* context, const WatchpointHistoryRequest* request,
WatchpointHistoryResponse* response) override;
// Execution Control
grpc::Status StepInstruction(grpc::ServerContext* context,
const Empty* request,
StepResponse* response) override;
grpc::Status RunToBreakpoint(grpc::ServerContext* context,
const Empty* request,
BreakpointHitResponse* response) override;
grpc::Status StepOver(grpc::ServerContext* context, const Empty* request,
StepResponse* response) override;
grpc::Status StepOut(grpc::ServerContext* context, const Empty* request,
StepResponse* response) override;
const agent::Empty* request,
agent::BreakpointHitResponse* response) override;
// Disassembly & Code Analysis
// --- Input & State ---
grpc::Status PressButtons(grpc::ServerContext* context,
const agent::ButtonRequest* request,
agent::CommandResponse* response) override;
grpc::Status HoldButtons(grpc::ServerContext* context,
const agent::ButtonHoldRequest* request,
agent::CommandResponse* response) override;
grpc::Status GetGameState(grpc::ServerContext* context,
const agent::GameStateRequest* request,
agent::GameStateResponse* response) override;
grpc::Status ReadMemory(grpc::ServerContext* context,
const agent::MemoryRequest* request,
agent::MemoryResponse* response) override;
grpc::Status WriteMemory(grpc::ServerContext* context,
const agent::MemoryWriteRequest* request,
agent::CommandResponse* response) override;
// --- Debugging Management ---
grpc::Status BreakpointControl(grpc::ServerContext* context,
const agent::BreakpointControlRequest* request,
agent::BreakpointControlResponse* response) override;
grpc::Status WatchpointControl(grpc::ServerContext* context,
const agent::WatchpointControlRequest* request,
agent::WatchpointControlResponse* response) override;
// --- Analysis & Symbols ---
grpc::Status GetDisassembly(grpc::ServerContext* context,
const DisassemblyRequest* request,
DisassemblyResponse* response) override;
const agent::DisassemblyRequest* request,
agent::DisassemblyResponse* response) override;
grpc::Status GetExecutionTrace(grpc::ServerContext* context,
const TraceRequest* request,
TraceResponse* response) override;
// Symbol Management
grpc::Status LoadSymbols(grpc::ServerContext* context,
const SymbolFileRequest* request,
CommandResponse* response) override;
const agent::TraceRequest* request,
agent::TraceResponse* response) override;
grpc::Status ResolveSymbol(grpc::ServerContext* context,
const SymbolLookupRequest* request,
SymbolLookupResponse* response) override;
const agent::SymbolLookupRequest* request,
agent::SymbolLookupResponse* response) override;
grpc::Status GetSymbolAt(grpc::ServerContext* context,
const AddressRequest* request,
SymbolLookupResponse* response) override;
const agent::AddressRequest* request,
agent::SymbolLookupResponse* response) override;
grpc::Status LoadSymbols(grpc::ServerContext* context,
const agent::SymbolFileRequest* request,
agent::CommandResponse* response) override;
// Debugging Session
grpc::Status CreateDebugSession(grpc::ServerContext* context,
const DebugSessionRequest* request,
DebugSessionResponse* response) override;
// --- Session & Experiments ---
grpc::Status GetDebugStatus(grpc::ServerContext* context,
const Empty* request,
DebugStatusResponse* response) override;
const agent::Empty* request,
agent::DebugStatusResponse* response) override;
grpc::Status TestRun(grpc::ServerContext* context,
const agent::TestRunRequest* request,
agent::TestRunResponse* response) override;
private:
void InitializeStepController();
void CaptureCPUState(agent::CPUState* state);
yaze::emu::Emulator*
emulator_; // Non-owning pointer to the emulator instance
RomGetter rom_getter_;
yaze::emu::debug::SymbolProvider symbol_provider_; // Symbol table for debugging
yaze::emu::debug::StepController step_controller_; // Call stack tracking
yaze::emu::debug::StepController step_controller_;
};
} // namespace yaze::agent
} // namespace yaze::net

3
src/cli/service/agent/rom_debug_agent.cc
View File

@@ -2,6 +2,7 @@
#include <algorithm>
#include <iomanip>
#include <set>
#include <sstream>
#include "absl/strings/str_format.h"
@@ -76,7 +77,7 @@ bool ModifiesStack(uint8_t opcode) {
} // namespace
RomDebugAgent::RomDebugAgent(yaze::agent::EmulatorServiceImpl* emulator_service)
RomDebugAgent::RomDebugAgent(yaze::net::EmulatorServiceImpl* emulator_service)
: emulator_service_(emulator_service),
disassembler_(std::make_unique<Disassembler65816>()),
symbol_provider_(std::make_unique<yaze::emu::debug::SymbolProvider>()) {

4
src/cli/service/agent/rom_debug_agent.h
View File

@@ -106,7 +106,7 @@ class RomDebugAgent {
};
// Constructor
explicit RomDebugAgent(yaze::agent::EmulatorServiceImpl* emulator_service);
explicit RomDebugAgent(yaze::net::EmulatorServiceImpl* emulator_service);
// --- Core Analysis Functions ---
@@ -277,7 +277,7 @@ class RomDebugAgent {
std::optional<std::string> GetStructureInfo(uint32_t address) const;
// Member variables
yaze::agent::EmulatorServiceImpl* emulator_service_; // Non-owning pointer
yaze::net::EmulatorServiceImpl* emulator_service_; // Non-owning pointer
std::unique_ptr<Disassembler65816> disassembler_;
std::unique_ptr<yaze::emu::debug::SymbolProvider> symbol_provider_;
std::vector<uint8_t> original_rom_; // Original ROM for comparison

2
src/cli/service/net/z3ed_network_client.cc
View File

@@ -12,7 +12,9 @@
#ifdef YAZE_WITH_JSON
#include "nlohmann/json.hpp"
#if !defined(_WIN32) && !defined(YAZE_IOS)
#define CPPHTTPLIB_OPENSSL_SUPPORT
#endif
#include "httplib.h"
#endif

319
src/protos/emulator_service.proto
View File

@@ -2,56 +2,41 @@ syntax = "proto3";
package yaze.agent;
// The main service for controlling the yaze emulator
// The consolidated service for controlling the yaze emulator
service EmulatorService {
// --- Lifecycle ---
rpc Start(Empty) returns (CommandResponse);
rpc Stop(Empty) returns (CommandResponse);
rpc Pause(Empty) returns (CommandResponse);
rpc Resume(Empty) returns (CommandResponse);
rpc Reset(Empty) returns (CommandResponse);
// --- Core Lifecycle & Control ---
// action: "start", "stop", "pause", "resume", "reset"
rpc ControlEmulator(ControlRequest) returns (CommandResponse);
// --- Input Control ---
// mode: "instruction", "over", "out"
rpc StepEmulator(StepControlRequest) returns (StepResponse);
rpc RunToBreakpoint(Empty) returns (BreakpointHitResponse);
// --- Input & State ---
rpc PressButtons(ButtonRequest) returns (CommandResponse);
rpc ReleaseButtons(ButtonRequest) returns (CommandResponse);
rpc HoldButtons(ButtonHoldRequest) returns (CommandResponse);
// --- State Inspection (The Feedback Loop) ---
rpc GetGameState(GameStateRequest) returns (GameStateResponse);
rpc ReadMemory(MemoryRequest) returns (MemoryResponse);
rpc WriteMemory(MemoryWriteRequest) returns (CommandResponse);
// --- Advanced Debugging (NEW) ---
// Breakpoints
rpc AddBreakpoint(BreakpointRequest) returns (BreakpointResponse);
rpc RemoveBreakpoint(BreakpointIdRequest) returns (CommandResponse);
rpc ListBreakpoints(Empty) returns (BreakpointListResponse);
rpc SetBreakpointEnabled(BreakpointStateRequest) returns (CommandResponse);
// --- Debugging Management ---
// action: "add", "remove", "list", "toggle"
rpc BreakpointControl(BreakpointControlRequest) returns (BreakpointControlResponse);
// Watchpoints (memory access tracking)
rpc AddWatchpoint(WatchpointRequest) returns (WatchpointResponse);
rpc RemoveWatchpoint(WatchpointIdRequest) returns (CommandResponse);
rpc ListWatchpoints(Empty) returns (WatchpointListResponse);
rpc GetWatchpointHistory(WatchpointHistoryRequest) returns (WatchpointHistoryResponse);
// action: "add", "remove", "list", "history"
rpc WatchpointControl(WatchpointControlRequest) returns (WatchpointControlResponse);
// Execution Control
rpc StepInstruction(Empty) returns (StepResponse);
rpc RunToBreakpoint(Empty) returns (BreakpointHitResponse);
rpc StepOver(Empty) returns (StepResponse); // Step over subroutines
rpc StepOut(Empty) returns (StepResponse); // Step out of subroutine
// Disassembly & Code Analysis
// --- Analysis & Symbols ---
rpc GetDisassembly(DisassemblyRequest) returns (DisassemblyResponse);
rpc GetExecutionTrace(TraceRequest) returns (TraceResponse);
// Symbol Management (for Oracle of Secrets labels)
rpc LoadSymbols(SymbolFileRequest) returns (CommandResponse);
rpc ResolveSymbol(SymbolLookupRequest) returns (SymbolLookupResponse);
rpc GetSymbolAt(AddressRequest) returns (SymbolLookupResponse);
rpc LoadSymbols(SymbolFileRequest) returns (CommandResponse);
// Debugging Session
rpc CreateDebugSession(DebugSessionRequest) returns (DebugSessionResponse);
// --- Session & Experiments ---
rpc GetDebugStatus(Empty) returns (DebugStatusResponse);
rpc TestRun(TestRunRequest) returns (TestRunResponse);
}
// --- Message Definitions ---
@@ -63,20 +48,15 @@ message CommandResponse {
string message = 2;
}
message ControlRequest {
string action = 1; // "start", "stop", "pause", "resume", "reset"
}
enum Button {
BUTTON_UNSPECIFIED = 0;
A = 1;
B = 2;
X = 3;
Y = 4;
L = 5;
R = 6;
SELECT = 7;
START = 8;
UP = 9;
DOWN = 10;
LEFT = 11;
RIGHT = 12;
A = 1; B = 2; X = 3; Y = 4;
L = 5; R = 6; SELECT = 7; START = 8;
UP = 9; DOWN = 10; LEFT = 11; RIGHT = 12;
}
message ButtonRequest {
@@ -85,7 +65,7 @@ message ButtonRequest {
message ButtonHoldRequest {
repeated Button buttons = 1;
uint32 duration_ms = 2; // How long to hold the buttons
uint32 duration_ms = 2;
}
message GameStateRequest {
@@ -94,17 +74,12 @@ message GameStateRequest {
}
message GameStateResponse {
// Key player and game variables
uint32 game_mode = 1;
uint32 link_state = 2;
uint32 link_pos_x = 3;
uint32 link_pos_y = 4;
uint32 link_health = 5;
// Screenshot of the current frame
bytes screenshot_png = 6; // PNG encoded image data
// Results of any requested memory reads
bytes screenshot_png = 6;
repeated MemoryResponse memory_responses = 7;
}
@@ -123,47 +98,28 @@ message MemoryWriteRequest {
bytes data = 2;
}
// --- Advanced Debugging Messages (NEW) ---
// --- Breakpoint Control ---
// Breakpoint types (matches BreakpointManager::Type)
enum BreakpointType {
BREAKPOINT_TYPE_UNSPECIFIED = 0;
EXECUTE = 1; // Break when PC reaches address
READ = 2; // Break when memory is read
WRITE = 3; // Break when memory is written
ACCESS = 4; // Break on read OR write
CONDITIONAL = 5; // Break when condition is true
EXECUTE = 1; READ = 2; WRITE = 3; ACCESS = 4; CONDITIONAL = 5;
}
// CPU type for breakpoints
enum CpuType {
CPU_TYPE_UNSPECIFIED = 0;
CPU_65816 = 1;
SPC700 = 2;
}
// Breakpoint request
message BreakpointRequest {
uint32 address = 1;
BreakpointType type = 2;
CpuType cpu = 3;
string condition = 4; // Optional condition (e.g., "A > 0x10")
string description = 5; // User-friendly label
}
message BreakpointResponse {
bool success = 1;
uint32 breakpoint_id = 2;
string message = 3;
}
message BreakpointIdRequest {
uint32 breakpoint_id = 1;
}
message BreakpointStateRequest {
uint32 breakpoint_id = 1;
bool enabled = 2;
message BreakpointControlRequest {
string action = 1; // "add", "remove", "list", "toggle"
uint32 id = 2; // For remove/toggle
uint32 address = 3; // For add
BreakpointType type = 4;
CpuType cpu = 5;
string condition = 6;
string description = 7;
bool enabled = 8;
}
message BreakpointInfo {
@@ -177,35 +133,25 @@ message BreakpointInfo {
uint32 hit_count = 8;
}
message BreakpointListResponse {
repeated BreakpointInfo breakpoints = 1;
}
message BreakpointHitResponse {
bool hit = 1;
BreakpointInfo breakpoint = 2;
CPUState cpu_state = 3;
string message = 4;
}
// Watchpoint messages
message WatchpointRequest {
uint32 start_address = 1;
uint32 end_address = 2; // For range watchpoints
bool track_reads = 3;
bool track_writes = 4;
bool break_on_access = 5;
string description = 6;
}
message WatchpointResponse {
message BreakpointControlResponse {
bool success = 1;
uint32 watchpoint_id = 2;
string message = 3;
string message = 2;
uint32 breakpoint_id = 3; // For newly added
repeated BreakpointInfo breakpoints = 4; // For list
}
message WatchpointIdRequest {
uint32 watchpoint_id = 1;
// --- Watchpoint Control ---
message WatchpointControlRequest {
string action = 1; // "add", "remove", "list", "history"
uint32 id = 2;
uint32 start_address = 3;
uint32 end_address = 4;
bool track_reads = 5;
bool track_writes = 6;
bool break_on_access = 7;
string description = 8;
uint32 max_entries = 9; // For history
}
message WatchpointInfo {
@@ -219,15 +165,6 @@ message WatchpointInfo {
string description = 8;
}
message WatchpointListResponse {
repeated WatchpointInfo watchpoints = 1;
}
message WatchpointHistoryRequest {
uint32 watchpoint_id = 1;
uint32 max_entries = 2; // Max history entries to return
}
message AccessLogEntry {
uint32 pc = 1;
uint32 address = 2;
@@ -235,133 +172,95 @@ message AccessLogEntry {
uint32 new_value = 4;
bool is_write = 5;
uint64 cycle_count = 6;
string description = 7;
}
message WatchpointHistoryResponse {
repeated AccessLogEntry history = 1;
message WatchpointControlResponse {
bool success = 1;
string message = 2;
uint32 watchpoint_id = 3;
repeated WatchpointInfo watchpoints = 4;
repeated AccessLogEntry history = 5;
}
// --- Stepping & Status ---
message StepControlRequest {
string mode = 1; // "instruction", "over", "out"
}
// CPU State (for stepping/debugging)
message CPUState {
uint32 a = 1;
uint32 x = 2;
uint32 y = 3;
uint32 sp = 4;
uint32 pc = 5;
uint32 db = 6; // Data bank
uint32 pb = 7; // Program bank
uint32 d = 8; // Direct page
uint32 status = 9; // Processor status
bool flag_n = 10; // Negative
bool flag_v = 11; // Overflow
bool flag_d = 12; // Decimal
bool flag_i = 13; // Interrupt disable
bool flag_z = 14; // Zero
bool flag_c = 15; // Carry
uint64 cycles = 16;
uint32 a = 1; uint32 x = 2; uint32 y = 3; uint32 sp = 4;
uint32 pc = 5; uint32 db = 6; uint32 pb = 7; uint32 d = 8;
uint32 status = 9;
bool flag_n = 10; bool flag_v = 11; bool flag_z = 12; bool flag_c = 13;
uint64 cycles = 14;
}
message StepResponse {
bool success = 1;
CPUState cpu_state = 2;
DisassemblyLine instruction = 3;
string message = 4;
string message = 2;
CPUState cpu_state = 3;
}
message BreakpointHitResponse {
bool hit = 1;
BreakpointInfo breakpoint = 2;
CPUState cpu_state = 3;
}
// Disassembly messages
message DisassemblyRequest {
uint32 start_address = 1;
uint32 count = 2; // Number of instructions
bool include_execution_count = 3;
uint32 count = 2;
}
message DisassemblyLine {
uint32 address = 1;
uint32 opcode = 2;
repeated uint32 operands = 3;
string mnemonic = 4;
string operand_str = 5;
uint32 size = 6;
uint64 execution_count = 7;
bool is_breakpoint = 8;
string mnemonic = 2;
string operand_str = 3;
bool is_breakpoint = 4;
}
message DisassemblyResponse {
repeated DisassemblyLine lines = 1;
}
// Execution trace
message TraceRequest {
uint32 max_entries = 1; // Max trace entries to return
uint32 start_address = 2; // Optional: filter by address range
uint32 end_address = 3;
}
message TraceEntry {
uint32 address = 1;
string instruction = 2;
CPUState cpu_state_before = 3;
uint64 cycle_count = 4;
uint32 opcode = 5;
}
message TraceRequest { uint32 max_entries = 1; }
message TraceResponse {
repeated TraceEntry entries = 1;
uint32 total_count = 2;
message Entry { uint32 address = 1; string instruction = 2; uint32 opcode = 3; }
repeated Entry entries = 1;
}
// Symbol management
message SymbolFileRequest {
string filepath = 1; // Path to symbol file (e.g., .sym, .map)
SymbolFormat format = 2;
}
enum SymbolFormat {
SYMBOL_FORMAT_UNSPECIFIED = 0;
ASAR = 1; // Asar assembler format
WLA_DX = 2; // WLA-DX assembler format
CA65 = 3; // ca65 assembler format
MESEN = 4; // Mesen debug symbol format
CUSTOM_JSON = 5; // Custom JSON format
}
message SymbolLookupRequest {
string symbol_name = 1;
}
message AddressRequest {
uint32 address = 1;
string filepath = 1;
enum Format { AUTO = 0; ASAR = 1; WLA_DX = 2; MESEN = 3; }
Format format = 2;
}
message SymbolLookupRequest { string symbol_name = 1; }
message AddressRequest { uint32 address = 1; }
message SymbolLookupResponse {
bool found = 1;
string symbol_name = 2;
uint32 address = 3;
string type = 4; // "function", "data", "label", etc.
string description = 5;
}
// Debug session
message DebugSessionRequest {
string session_name = 1;
string rom_hash = 2; // For verification
bool enable_all_features = 3;
}
message DebugSessionResponse {
bool success = 1;
string session_id = 2;
string message = 3;
string type = 4;
}
message DebugStatusResponse {
bool is_running = 1;
bool is_paused = 2;
CPUState cpu_state = 3;
uint32 active_breakpoints = 4;
uint32 active_watchpoints = 5;
BreakpointInfo last_breakpoint_hit = 6;
double fps = 7;
uint64 cycles = 8;
CPUState cpu_state = 2;
uint32 active_breakpoints = 3;
}
message TestRunRequest {
uint32 address = 1;
bytes data = 2;
uint32 frame_count = 3;
bool reset_after = 4;
}
message TestRunResponse {
bool success = 1;
string message = 2;
CPUState final_cpu_state = 3;
bool crashed = 4;
}