Add write tracer, search history, DMA health monitoring, and UI improvements

- Write Tracer panel: reverse control flow analysis to find memory write handlers
  with direct writes table and call graph tree view
- Search history: persistent query history with dropdown in pattern/memory/disasm panels
- DMA health monitoring: periodic test reads with connection status banner
- Data type inspector sidebar in memory viewer
- Toast notification system for async operation feedback
- Cached process list with dirty-flag pattern to avoid per-frame sort
- Disassembler refactored to use RAII (unique_ptr) for Zydis decoder/formatter
- Thread safety fixes for async progress state (mutex + atomics)
- Safe hex parsing via ParseHexAddress() replacing raw strtoull calls
- OpenGL texture leak fix in shutdown path
- CS2 schema type safety improvements

Author: super2xl

mcp_bridge.js

@@ -210,6 +210,28 @@ const MCP_TOOLS = [
       required: ['pid', 'address', 'size']
     }
   },
+  {
+    name: 'write_memory',
+    description: 'Write data to process memory via DMA. Takes a hex string of bytes to write at the specified address. Returns the address and number of bytes written. Requires allow_write to be enabled in config.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pid: {
+          type: 'integer',
+          description: 'Process ID to write to'
+        },
+        address: {
+          type: 'string',
+          description: 'Memory address in hexadecimal (e.g., "0x7FF600000000" or "7FF600000000")'
+        },
+        data: {
+          type: 'string',
+          description: 'Hex string of bytes to write (e.g., "90 90 90" or "909090"). Spaces optional.'
+        }
+      },
+      required: ['pid', 'address', 'data']
+    }
+  },
   {
     name: 'scan_pattern',
     description: 'Scan for byte pattern in process memory using IDA-style pattern syntax. Returns array of matching addresses.',
@@ -1654,6 +1676,7 @@ const TOOL_ENDPOINT_MAP = {
   'get_health': { method: 'GET', path: '/health' },
   'get_version': { method: 'GET', path: '/version' },
   'read_memory': { method: 'POST', path: '/tools/read_memory' },
+  'write_memory': { method: 'POST', path: '/tools/write_memory' },
   'scan_pattern': { method: 'POST', path: '/tools/scan_pattern' },
   'scan_pattern_async': { method: 'POST', path: '/tools/scan_pattern_async' },
   'scan_strings': { method: 'POST', path: '/tools/scan_strings' },

src/analysis/disassembler.cpp

@@ -19,56 +19,45 @@ Disassembler::~Disassembler() {
 
 Disassembler::Disassembler(Disassembler&& other) noexcept
     : is_64bit_(other.is_64bit_)
-    , decoder_(other.decoder_)
-    , formatter_(other.formatter_) {
-    other.decoder_ = nullptr;
-    other.formatter_ = nullptr;
+    , decoder_(std::move(other.decoder_))
+    , formatter_(std::move(other.formatter_)) {
 }
 
 Disassembler& Disassembler::operator=(Disassembler&& other) noexcept {
     if (this != &other) {
-        CleanupDecoder();
         is_64bit_ = other.is_64bit_;
-        decoder_ = other.decoder_;
-        formatter_ = other.formatter_;
-        other.decoder_ = nullptr;
-        other.formatter_ = nullptr;
+        decoder_ = std::move(other.decoder_);
+        formatter_ = std::move(other.formatter_);
     }
     return *this;
 }
 
 void Disassembler::InitDecoder() {
-    decoder_ = new ZydisDecoder;
-    formatter_ = new ZydisFormatter;
+    decoder_ = std::make_unique<ZydisDecoder>();
+    formatter_ = std::make_unique<ZydisFormatter>();
 
     ZydisMachineMode mode = is_64bit_ ? ZYDIS_MACHINE_MODE_LONG_64 : ZYDIS_MACHINE_MODE_LEGACY_32;
     ZydisStackWidth stack_width = is_64bit_ ? ZYDIS_STACK_WIDTH_64 : ZYDIS_STACK_WIDTH_32;
 
-    if (!ZYAN_SUCCESS(ZydisDecoderInit(decoder_, mode, stack_width))) {
+    if (!ZYAN_SUCCESS(ZydisDecoderInit(decoder_.get(), mode, stack_width))) {
         CleanupDecoder();
         return;
     }
 
-    if (!ZYAN_SUCCESS(ZydisFormatterInit(formatter_, ZYDIS_FORMATTER_STYLE_INTEL))) {
+    if (!ZYAN_SUCCESS(ZydisFormatterInit(formatter_.get(), ZYDIS_FORMATTER_STYLE_INTEL))) {
         CleanupDecoder();
         return;
     }
 
     // Configure formatter
-    ZydisFormatterSetProperty(formatter_, ZYDIS_FORMATTER_PROP_FORCE_SIZE, ZYAN_FALSE);
-    ZydisFormatterSetProperty(formatter_, ZYDIS_FORMATTER_PROP_UPPERCASE_MNEMONIC, ZYAN_TRUE);
-    ZydisFormatterSetProperty(formatter_, ZYDIS_FORMATTER_PROP_UPPERCASE_REGISTERS, ZYAN_TRUE);
+    ZydisFormatterSetProperty(formatter_.get(), ZYDIS_FORMATTER_PROP_FORCE_SIZE, ZYAN_FALSE);
+    ZydisFormatterSetProperty(formatter_.get(), ZYDIS_FORMATTER_PROP_UPPERCASE_MNEMONIC, ZYAN_TRUE);
+    ZydisFormatterSetProperty(formatter_.get(), ZYDIS_FORMATTER_PROP_UPPERCASE_REGISTERS, ZYAN_TRUE);
 }
 
 void Disassembler::CleanupDecoder() {
-    if (decoder_) {
-        delete decoder_;
-        decoder_ = nullptr;
-    }
-    if (formatter_) {
-        delete formatter_;
-        formatter_ = nullptr;
-    }
+    decoder_.reset();
+    formatter_.reset();
 }
 
 std::optional<InstructionInfo> Disassembler::DisassembleOne(const uint8_t* data,
@@ -81,7 +70,7 @@ std::optional<InstructionInfo> Disassembler::DisassembleOne(const uint8_t* data,
     ZydisDecodedInstruction instruction;
     ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT];
 
-    if (!ZYAN_SUCCESS(ZydisDecoderDecodeFull(decoder_, data, size,
+    if (!ZYAN_SUCCESS(ZydisDecoderDecodeFull(decoder_.get(), data, size,
                                               &instruction, operands))) {
         return std::nullopt;
     }
@@ -95,7 +84,7 @@ std::optional<InstructionInfo> Disassembler::DisassembleOne(const uint8_t* data,
 
     // Format instruction
     char buffer[256];
-    if (ZYAN_SUCCESS(ZydisFormatterFormatInstruction(formatter_, &instruction,
+    if (ZYAN_SUCCESS(ZydisFormatterFormatInstruction(formatter_.get(), &instruction,
                                                       operands, instruction.operand_count_visible,
                                                       buffer, sizeof(buffer), address, nullptr))) {
         info.full_text = buffer;
@@ -149,10 +138,20 @@ std::optional<InstructionInfo> Disassembler::DisassembleOne(const uint8_t* data,
 
     // Check for memory access
     info.is_memory_access = false;
+    info.is_memory_write = false;
+    info.is_memory_read = false;
     for (size_t i = 0; i < instruction.operand_count; i++) {
         if (operands[i].type == ZYDIS_OPERAND_TYPE_MEMORY) {
             info.is_memory_access = true;
 
+            // Determine read/write via Zydis operand actions
+            if (operands[i].actions & ZYDIS_OPERAND_ACTION_MASK_WRITE) {
+                info.is_memory_write = true;
+            }
+            if (operands[i].actions & ZYDIS_OPERAND_ACTION_MASK_READ) {
+                info.is_memory_read = true;
+            }
+
             // Calculate memory address if possible
             ZyanU64 result;
             if (ZYAN_SUCCESS(ZydisCalcAbsoluteAddress(&instruction, &operands[i], address, &result))) {

src/analysis/disassembler.h

@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <optional>
 #include <map>
+#include <memory>
 
 // Forward declare Zydis types to avoid header inclusion in header
 struct ZydisDecoder_;
@@ -48,6 +49,8 @@ struct InstructionInfo {
     bool is_ret;
     bool is_conditional;
     bool is_memory_access;
+    bool is_memory_write;       // Memory operand is written (MOV [addr], ..., ADD [addr], ...)
+    bool is_memory_read;        // Memory operand is read
 
     // Branch target (if applicable)
     std::optional<uint64_t> branch_target;
@@ -155,8 +158,8 @@ class Disassembler {
     void CleanupDecoder();
 
     bool is_64bit_;
-    ZydisDecoder_* decoder_ = nullptr;
-    ZydisFormatter_* formatter_ = nullptr;
+    std::unique_ptr<ZydisDecoder_> decoder_;
+    std::unique_ptr<ZydisFormatter_> formatter_;
 };
 
 /**