Fix up application handing when shutting down

Author: mattnelsonuk

CHANGELOG.md

@@ -5,6 +5,12 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ## [staging]
 
 
+## [0.1.1] - 2026-03-17
+### Fixed
+- Fix REAPER hanging on exit due to client TCP sockets not being shut down during server stop, causing blocking `recv()` calls in client threads to never return
+- Unregister timer callback (`-timer`) during plugin unload to prevent use-after-free of destroyed globals
+- Drain pending command queue on shutdown so in-flight futures resolve instead of blocking indefinitely
+
 ## [0.1.0] - 2026-03-17
 ### Added
 - Initial Build. Artefacts are built for Linux, Windows, and macOS and published to GitHub releases.

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.15)
-project(reaserve VERSION 0.1.0 LANGUAGES CXX)
+project(reaserve VERSION 0.1.1 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

DEVELOPMENT.md

@@ -81,7 +81,7 @@ Triggered by pushing a `v*` tag. Builds and tests all three platforms, then crea
 
 ### Making a Release
 
-```bash
+```
 # 1. Bump version in CMakeLists.txt
 #    project(reaserve VERSION 0.2.0 LANGUAGES CXX)
 

README.md

@@ -4,6 +4,9 @@ A standalone C++ REAPER extension plugin that exposes common REAPER operations o
 
 Control REAPER from any language — Python, Go, Node.js, Rust, or anything that can open a TCP socket.
 
+This project ahs been built to help facilitate AI integration with REAPER, but can be used for any remote control use case. This plugin does not require a "file based bridge" or for the http server to be enabled. It can execute commands and return results entirely over TCP.
+
+
 ## Installation
 
 1. Download `reaper_reaserve` for your platform from [Releases](../../releases)
@@ -36,15 +39,21 @@ python examples/python_client.py
 go run examples/go_client.go
 ```
 
-If you have installed hte plugin correctly, both should print the JSON-RPC response:
+If you have installed hte plugin correctly, the example scripts will print the JSON-RPC responses for the example commands sent in:
 
 ```
 $ go run go_client.go
 
 Ping: {"pong":true,"version":"0.1.0"}
 
 Project: 120 BPM, 4 tracks
+  Track 0: Melody (0.0 dB)
+  Track 1: Bass (-1.9 dB)
+  Track 2: Chords (-4.4 dB)
+  Track 3: Drums (-0.9 dB)
 
+Transport: stopped at 15.00s
+  
 Added track: {"index":4,"success":true,"track_count":5}
 ```
 
@@ -86,6 +95,11 @@ The plugin binary will be at `build/reaper_reaserve.so` (Linux), `.dylib` (macOS
 
 ## Architecture
 
+Note: The timer callback processes up to 5 commands per tick
+
+![reaserve diagram](files/reaserve.png)
+
+
 ```mermaid
 graph TD
     Client([TCP Client]) <-->|JSON-RPC over TCP| Server

files/reaserve.png

@@ -81,11 +81,22 @@ REAPER_PLUGIN_DLL_EXPORT int ReaperPluginEntry(
     (void)hInstance;
 
     if (!rec) {
-        // Unloading
+        // Unloading — order matters to avoid deadlock:
+        // 1. Unregister timer first so no new commands are processed
+        reaserve::api::plugin_register("-timer", (void*)timer_callback);
+
+        // 2. Stop server (closes sockets, joins threads)
         if (g_server) {
             g_server->stop();
             g_server.reset();
         }
+
+        // 3. Drain any remaining commands so their futures don't block
+        while (auto cmd = g_queue.try_pop()) {
+            cmd->response.set_value(
+                reaserve::make_error(cmd->id, reaserve::ERR_TIMEOUT,
+                    "Plugin shutting down"));
+        }
         return 0;
     }
 

src/main.cpp

@@ -5,6 +5,7 @@
     #include <ws2tcpip.h>
     using socket_t = SOCKET;
     constexpr socket_t INVALID_SOCK = INVALID_SOCKET;
+    constexpr int SHUT_RDWR_COMPAT = SD_BOTH;
     inline int close_socket(socket_t s) { return closesocket(s); }
     inline bool init_sockets() {
         WSADATA wsa;
@@ -19,6 +20,7 @@
     #include <cerrno>
     using socket_t = int;
     constexpr socket_t INVALID_SOCK = -1;
+    constexpr int SHUT_RDWR_COMPAT = SHUT_RDWR;
     inline int close_socket(socket_t s) { return close(s); }
     inline bool init_sockets() { return true; }
     inline void cleanup_sockets() {}

src/platform.h

@@ -95,9 +95,22 @@ bool TcpServer::start() {
 void TcpServer::stop() {
     running_ = false;
     if (listen_sock_ != INVALID_SOCK) {
+        shutdown(listen_sock_, SHUT_RDWR_COMPAT);
         close_socket(listen_sock_);
         listen_sock_ = INVALID_SOCK;
     }
+
+    // Shutdown all active client sockets so their blocking recv() calls
+    // return immediately instead of hanging until the remote end closes.
+    {
+        std::lock_guard<std::mutex> lock(clients_mutex_);
+        for (auto sock : active_client_sockets_) {
+            shutdown(sock, SHUT_RDWR_COMPAT);
+            close_socket(sock);
+        }
+        active_client_sockets_.clear();
+    }
+
     if (accept_thread_.joinable()) {
         accept_thread_.join();
     }
@@ -133,6 +146,7 @@ void TcpServer::accept_loop() {
                 }),
             client_threads_.end()
         );
+        active_client_sockets_.push_back(client);
         client_threads_.emplace_back(&TcpServer::client_loop, this, client);
     }
 }
@@ -146,6 +160,14 @@ void TcpServer::client_loop(socket_t client_sock) {
         if (!framing::write_message(client_sock, response)) break;
     }
     close_socket(client_sock);
+
+    // Remove from active set
+    {
+        std::lock_guard<std::mutex> lock(clients_mutex_);
+        active_client_sockets_.erase(
+            std::remove(active_client_sockets_.begin(), active_client_sockets_.end(), client_sock),
+            active_client_sockets_.end());
+    }
 }
 
 } // namespace reaserve

src/tcp_server.cpp

@@ -44,6 +44,7 @@ class TcpServer {
     socket_t listen_sock_ = INVALID_SOCK;
     std::thread accept_thread_;
     std::vector<std::thread> client_threads_;
+    std::vector<socket_t> active_client_sockets_;
     std::mutex clients_mutex_;
 };