Method dispatch

src/librenef/cmd/cmd_load.cpp:38–115

    }

    CommandResult dispatch(int client_fd, const char* cmd_buffer, size_t cmd_size) override {
        std::vector<std::string> cmd_parts = split(cmd_buffer, ' ');
        if (cmd_parts.size() < 2) {
            const char* error = "ERROR: Usage: l <filename>\n";
            write(client_fd, error, strlen(error));
            return CommandResult(false, "Invalid arguments");
        }

        std::string file_path = cmd_parts[1];

        std::string lua_script = read_file(file_path.c_str());
        if (lua_script.empty()) {
            std::string error = "ERROR: Cannot read file: " + file_path + "\n";
            write(client_fd, error.c_str(), error.length());
            return CommandResult(false, "File read failed");
        }

        int pid = CommandRegistry::instance().get_current_pid();
        if (pid <= 0) {
            const char* error_msg = "ERROR: No target PID set. Please attach first.\n";
            write(client_fd, error_msg, strlen(error_msg));
            return CommandResult(false, "No target PID set");
        }

        SocketHelper& socket_helper = CommandRegistry::instance().get_socket_helper();
        int sock = socket_helper.ensure_connection(pid);
        if (sock < 0) {
            const char* error_msg = "ERROR: Failed to connect to agent\n";
            write(client_fd, error_msg, strlen(error_msg));
            return CommandResult(false, "Socket connection failed");
        }

        std::string hex = hex_encode(lua_script);
        std::string command = "hexexec " + hex + "\n";
        socket_helper.send_data(command.c_str(), command.length());

        // Spawn gate: resume frozen process after script data is buffered
        int gated = CommandRegistry::instance().gated_pid;
        if (gated > 0 && gated == pid) {
            fprintf(stderr, "[spawn-gate] Resuming gated process (pid=%d)\n", gated);
            kill(gated, SIGCONT);
            CommandRegistry::instance().gated_pid = -1;
        }

        int flags = fcntl(sock, F_GETFL, 0);
        fcntl(sock, F_SETFL, flags | O_NONBLOCK);

        char buffer[4096];
        bool script_done = false;
        int timeout_count = 0;
        const int max_timeout = 50;

        while (!script_done && timeout_count < max_timeout) {
            struct pollfd pfd = {sock, POLLIN, 0};
            int ret = poll(&pfd, 1, 100);

            if (ret > 0 && (pfd.revents & POLLIN)) {
                ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0);