cheatengine 5.8.20 → 5.8.22

package/ce_mcp_bridge.lua

@@ -26,15 +26,14 @@ local pairs = pairs
 local ipairs = ipairs
 local os_clock = os.clock
 
--- ============ Config ============
-local Config = {
-    VERSION = "5.8.4",
-    -- Pipe name: supports environment variable override for anti-detection
-    -- Set CE_MCP_PIPE_NAME environment variable to customize
-    PIPE_NAME = os.getenv("CE_MCP_PIPE_NAME") or "ce_mcp_bridge",
-    -- Authentication token: optional security layer for pipe communication
-    -- Set CE_MCP_AUTH_TOKEN environment variable to enable authentication
-    AUTH_TOKEN = os.getenv("CE_MCP_AUTH_TOKEN") or nil,
+-- ============ Config ============
+local Config = {
+    -- Pipe name: supports environment variable override for anti-detection
+    -- Set CE_MCP_PIPE_NAME environment variable to customize
+    PIPE_NAME = os.getenv("CE_MCP_PIPE_NAME") or "ce_mcp_bridge",
+    -- Authentication token: optional security layer for pipe communication
+    -- Set CE_MCP_AUTH_TOKEN environment variable to enable authentication
+    AUTH_TOKEN = os.getenv("CE_MCP_AUTH_TOKEN") or nil,
     DEBUG_MODE = false,
     MAX_MESSAGE_SIZE = 10 * 1024 * 1024,
     PIPE_BUFFER_SIZE = 1024 * 1024,
@@ -1459,17 +1458,16 @@ local function getDebuggerStatus()
     return status
 end
 
-Handlers.ping = function()
-    return {
-        status = "ok",
-        version = Config.VERSION,
-        timestamp = os.time(),
-        process = process or "N/A",
-        pid = getOpenedProcessID() or 0,
-        connections = Context.connectionCount,
-        debugger = getDebuggerStatus()
-    }
-end
+Handlers.ping = function()
+    return {
+        status = "ok",
+        timestamp = os.time(),
+        process = process or "N/A",
+        pid = getOpenedProcessID() or 0,
+        connections = Context.connectionCount,
+        debugger = getDebuggerStatus()
+    }
+end
 
 Handlers.get_process_info = function()
     -- Refresh symbol table using ModuleManager
@@ -1558,17 +1556,16 @@ Handlers.stats = function(p)
         })
     end
 
-    return {
-        version = Config.VERSION,
-        uptime = metrics.uptime,
-        commands = metrics.commands,
-        summary = metrics.summary,
-        cache = metrics.cache,
-        logging = logStats,
-        scanSessions = {
-            active = scanSessionCount,
-            maxAllowed = Config.MAX_SCAN_SESSIONS,
-            sessions = scanSessions
+    return {
+        uptime = metrics.uptime,
+        commands = metrics.commands,
+        summary = metrics.summary,
+        cache = metrics.cache,
+        logging = logStats,
+        scanSessions = {
+            active = scanSessionCount,
+            maxAllowed = Config.MAX_SCAN_SESSIONS,
+            sessions = scanSessions
         },
         connections = Context.connectionCount,
         debugger = getDebuggerStatus()
@@ -7488,121 +7485,174 @@ function Pipe.executeRequest(req)
     end
 end
 
-function Pipe.workerLoop()
-    Utils.debugPrint("Worker started")
-    local consecutiveErrors = 0
-
-    while Context.serverRunning do
-        local acceptOk, acceptErr = pcall(function()
-            Context.pipeServer.acceptConnection()
-        end)
-
-        if not acceptOk then
-            consecutiveErrors = consecutiveErrors + 1
-            if consecutiveErrors > Config.MAX_CONSECUTIVE_ERRORS then
-                Utils.debugPrint("Too many consecutive errors, restarting pipe...")
-                pcall(function() Context.pipeServer.destroy() end)
-                Context.pipeServer = createPipe(Config.PIPE_NAME, Config.PIPE_BUFFER_SIZE, Config.PIPE_BUFFER_SIZE)
-                consecutiveErrors = 0
-            end
-            if Context.serverRunning then
-                sleep(Config.HEARTBEAT_INTERVAL)
-            end
-        else
-            consecutiveErrors = 0
-            Context.connectionCount = Context.connectionCount + 1
-            Context.lastActivityTime = os_clock()  -- Heartbeat: record connection time
-            Utils.debugPrint("Client connected (#" .. Context.connectionCount .. ")")
-
-            local sessionErrors = 0
-
-            while Context.serverRunning and Context.pipeServer and Context.pipeServer.Valid do
-                Utils.periodicCleanup()
-
-                -- Read size
-                local ok, size = false, nil
-                pcall(function()
-                    Context.pipeServer.lock()
-                    ok, size = pcall(Context.pipeServer.readDword)
-                    Context.pipeServer.unlock()
-                end)
-
-                if not ok or not size or size == 0 then
-                    sessionErrors = sessionErrors + 1
-                    if sessionErrors >= Config.MAX_SESSION_ERRORS then
-                        Utils.debugPrint("Too many session errors, disconnecting client")
-                        break
-                    end
-                    sleep(10)
-                    goto continue
-                end
-
-                if size >= Config.MAX_MESSAGE_SIZE then
-                    Utils.debugPrint("Message too large: " .. size)
-                    break
-                end
-
-                sessionErrors = 0
-
-                -- Read payload
-                local ok2, payload = false, nil
-                pcall(function()
-                    Context.pipeServer.lock()
-                    ok2, payload = pcall(Context.pipeServer.readString, size)
-                    Context.pipeServer.unlock()
-                end)
-
-                if ok2 and payload and #payload == size then
-                    local req = JSON.decode(payload)
-                    local resp = nil
-
-                    -- Use optimized request execution (sync on demand)
-                    resp = Pipe.executeRequest(req)
-
-                    local respStr = JSON.encode(resp)
-                    local respLen = #respStr
-
-                    if respLen > Config.MAX_MESSAGE_SIZE then
-                        respStr = JSON.encode({ error = "Response too large" })
-                        respLen = #respStr
-                    end
-
-                    local writeOk = false
-                    pcall(function()
-                        Context.pipeServer.lock()
-                        writeOk = pcall(function()
-                            Context.pipeServer.writeDword(respLen)
-                            Context.pipeServer.writeString(respStr, false)
-                        end)
-                        Context.pipeServer.unlock()
-                    end)
-
-                    if writeOk then
-                        Context.lastActivityTime = os_clock()  -- Heartbeat: update on successful communication
-                    else
-                        Utils.debugPrint("Failed to write response")
-                        break
-                    end
-                else
-                    Utils.debugPrint("Failed to read payload")
-                    break
-                end
-
-                ::continue::
-            end
-
-            pcall(function()
-                if Context.pipeServer and Context.pipeServer.Valid then
-                    Context.pipeServer.disconnect()
-                end
-            end)
-            Context.lastActivityTime = 0  -- Heartbeat: reset on disconnect
-            Utils.debugPrint("Client disconnected, waiting for new connection...")
-            sleep(50)
-        end
-    end
-    Utils.debugPrint("Worker stopped")
-end
+-- Helper function to send error response without breaking connection
+local function sendErrorResponse(errorMsg)
+    local resp = { error = errorMsg }
+    local respStr = JSON.encode(resp)
+    local respLen = #respStr
+    
+    pcall(function()
+        Context.pipeServer.lock()
+        pcall(function()
+            Context.pipeServer.writeDword(respLen)
+            Context.pipeServer.writeString(respStr, false)
+        end)
+        Context.pipeServer.unlock()
+    end)
+end
+
+function Pipe.workerLoop()
+    Utils.debugPrint("Worker started")
+    local consecutiveErrors = 0
+
+    while Context.serverRunning do
+        local acceptOk, acceptErr = pcall(function()
+            Context.pipeServer.acceptConnection()
+        end)
+
+        if not acceptOk then
+            consecutiveErrors = consecutiveErrors + 1
+            if consecutiveErrors > Config.MAX_CONSECUTIVE_ERRORS then
+                Utils.debugPrint("Too many consecutive errors, restarting pipe...")
+                pcall(function() Context.pipeServer.destroy() end)
+                Context.pipeServer = createPipe(Config.PIPE_NAME, Config.PIPE_BUFFER_SIZE, Config.PIPE_BUFFER_SIZE)
+                consecutiveErrors = 0
+            end
+            if Context.serverRunning then
+                sleep(Config.HEARTBEAT_INTERVAL)
+            end
+        else
+            consecutiveErrors = 0
+            Context.connectionCount = Context.connectionCount + 1
+            Context.lastActivityTime = os_clock()  -- Heartbeat: record connection time
+            Utils.debugPrint("Client connected (#" .. Context.connectionCount .. ")")
+            
+            -- Handshake: send ready signal
+            local handshakeOk = pcall(function()
+                Context.pipeServer.lock()
+                local ok = pcall(function()
+                    local readyMsg = JSON.encode({ ready = true, timestamp = os.time() })
+                    Context.pipeServer.writeDword(#readyMsg)
+                    Context.pipeServer.writeString(readyMsg, false)
+                end)
+                Context.pipeServer.unlock()
+                return ok
+            end)
+            
+            if not handshakeOk then
+                Utils.debugPrint("Handshake failed, disconnecting client")
+                pcall(function()
+                    if Context.pipeServer and Context.pipeServer.Valid then
+                        Context.pipeServer.disconnect()
+                    end
+                end)
+                sleep(50)
+                goto next_connection
+            end
+            
+            Utils.debugPrint("Handshake completed")
+            local sessionErrors = 0
+
+            while Context.serverRunning and Context.pipeServer and Context.pipeServer.Valid do
+                Utils.periodicCleanup()
+
+                -- Read size
+                local ok, size = false, nil
+                pcall(function()
+                    Context.pipeServer.lock()
+                    ok, size = pcall(Context.pipeServer.readDword)
+                    Context.pipeServer.unlock()
+                end)
+
+                if not ok or not size or size == 0 then
+                    sessionErrors = sessionErrors + 1
+                    if sessionErrors >= Config.MAX_SESSION_ERRORS then
+                        Utils.debugPrint("Too many session errors, disconnecting client")
+                        -- Send error before disconnecting
+                        sendErrorResponse("Too many consecutive read errors")
+                        break
+                    end
+                    sleep(10)
+                    goto continue
+                end
+
+                if size >= Config.MAX_MESSAGE_SIZE then
+                    Utils.debugPrint("Message too large: " .. size)
+                    sendErrorResponse("Message too large: " .. size .. " bytes (max: " .. Config.MAX_MESSAGE_SIZE .. ")")
+                    break
+                end
+
+                sessionErrors = 0
+
+                -- Read payload
+                local ok2, payload = false, nil
+                pcall(function()
+                    Context.pipeServer.lock()
+                    ok2, payload = pcall(Context.pipeServer.readString, size)
+                    Context.pipeServer.unlock()
+                end)
+
+                if ok2 and payload and #payload == size then
+                    local decodeOk, req = pcall(JSON.decode, payload)
+                    if not decodeOk or not req then
+                        Utils.debugPrint("Failed to decode JSON payload")
+                        sendErrorResponse("Invalid JSON payload")
+                        goto continue
+                    end
+                    
+                    local resp = nil
+
+                    -- Use optimized request execution (sync on demand)
+                    resp = Pipe.executeRequest(req)
+
+                    local respStr = JSON.encode(resp)
+                    local respLen = #respStr
+
+                    if respLen > Config.MAX_MESSAGE_SIZE then
+                        respStr = JSON.encode({ error = "Response too large" })
+                        respLen = #respStr
+                    end
+
+                    local writeOk = false
+                    pcall(function()
+                        Context.pipeServer.lock()
+                        writeOk = pcall(function()
+                            Context.pipeServer.writeDword(respLen)
+                            Context.pipeServer.writeString(respStr, false)
+                        end)
+                        Context.pipeServer.unlock()
+                    end)
+
+                    if writeOk then
+                        Context.lastActivityTime = os_clock()  -- Heartbeat: update on successful communication
+                    else
+                        Utils.debugPrint("Failed to write response")
+                        break
+                    end
+                else
+                    Utils.debugPrint("Failed to read payload: expected " .. size .. " bytes")
+                    sendErrorResponse("Failed to read payload: expected " .. size .. " bytes, got " .. tostring(#(payload or "")))
+                    -- Don't break, allow client to retry
+                    sleep(50)
+                end
+
+                ::continue::
+            end
+
+            pcall(function()
+                if Context.pipeServer and Context.pipeServer.Valid then
+                    Context.pipeServer.disconnect()
+                end
+            end)
+            Context.lastActivityTime = 0  -- Heartbeat: reset on disconnect
+            Utils.debugPrint("Client disconnected, waiting for new connection...")
+            sleep(50)
+        end
+        
+        ::next_connection::
+    end
+    Utils.debugPrint("Worker stopped")
+end
 
 -- ============ Server Lifecycle ============
 local Server = {}
@@ -7631,13 +7681,13 @@ function Server.stop()
     Utils.debugPrint("Server stopped (handled " .. Context.connectionCount .. " connections)")
 end
 
-function Server.start()
-    Server.stop()  -- This calls cleanupZombieState()
-
-    -- Additional cleanup for fresh start
-    Utils.debugPrint("Starting MCP Bridge v" .. Config.VERSION)
-
-    Context.pipeServer = createPipe(Config.PIPE_NAME, Config.PIPE_BUFFER_SIZE, Config.PIPE_BUFFER_SIZE)
+function Server.start()
+    Server.stop()  -- This calls cleanupZombieState()
+
+    -- Additional cleanup for fresh start
+    Utils.debugPrint("Starting MCP Bridge")
+
+    Context.pipeServer = createPipe(Config.PIPE_NAME, Config.PIPE_BUFFER_SIZE, Config.PIPE_BUFFER_SIZE)
     if not Context.pipeServer or not Context.pipeServer.Valid then
         print("[CE-MCP] Failed to create pipe: " .. Config.PIPE_NAME)
         return false
@@ -7670,15 +7720,14 @@ function Server.stats()
         bpCount = bpCount + 1
     end
 
-    return {
-        running = Context.serverRunning,
-        connections = Context.connectionCount,
-        cached_symbols = symbolCacheCount,
-        cached_modules = moduleCacheCount,
-        active_breakpoints = bpCount,
-        version = Config.VERSION
-    }
-end
+    return {
+        running = Context.serverRunning,
+        connections = Context.connectionCount,
+        cached_symbols = symbolCacheCount,
+        cached_modules = moduleCacheCount,
+        active_breakpoints = bpCount
+    }
+end
 
 -- ============ Global API ============
 -- Cleanup old instance
@@ -7697,19 +7746,18 @@ if CE_MCP_STATUS_LABEL then
     end)
 end
 
-CE_MCP = {
-    start = Server.start,
-    stop = Server.stop,
-    stats = Server.stats,
-    version = Config.VERSION,
-    -- Logger API
-    Logger = Logger,
-    LogLevel = LogLevel,
-    -- Expose for debugging
-    _config = Config,
-    _context = Context,
-    _handlers = Handlers,
-}
+CE_MCP = {
+    start = Server.start,
+    stop = Server.stop,
+    stats = Server.stats,
+    -- Logger API
+    Logger = Logger,
+    LogLevel = LogLevel,
+    -- Expose for debugging
+    _config = Config,
+    _context = Context,
+    _handlers = Handlers,
+}
 
 CE_MCP_BRIDGE_INSTANCE = CE_MCP
 
@@ -7751,16 +7799,15 @@ function StatusLabel.create()
         label.Top = 5
     end
 
-    -- Click to show stats
-    label.OnClick = function()
-        local stats = Server.stats()
-        local connected = Context.lastActivityTime > 0 and
-                         (os_clock() - Context.lastActivityTime) < Config.HEARTBEAT_TIMEOUT
-        showMessage(string_format("CE MCP v%s\nStatus: %s\nConnections: %d",
-            Config.VERSION,
-            connected and "Connected" or "Waiting",
-            stats.connections or 0))
-    end
+    -- Click to show stats
+    label.OnClick = function()
+        local stats = Server.stats()
+        local connected = Context.lastActivityTime > 0 and
+                         (os_clock() - Context.lastActivityTime) < Config.HEARTBEAT_TIMEOUT
+        showMessage(string_format("CE MCP\nStatus: %s\nConnections: %d",
+            connected and "Connected" or "Waiting",
+            stats.connections or 0))
+    end
 
     StatusLabel.label = label
     StatusLabel.updateColor(false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cheatengine",
-  "version": "5.8.20",
+  "version": "5.8.22",
   "description": "Cheat Engine MCP Server - AI-assisted reverse engineering bridge",
   "main": "ce_mcp_server.js",
   "bin": {

package/src/pipe-client.js

@@ -86,30 +86,32 @@ class PipeClient extends EventEmitter {
   _handleData(data) {
     this.responseBuffer = Buffer.concat([this.responseBuffer, data]);
     
-    // Try to parse response
-    if (this.pendingResponse && this.responseBuffer.length >= 4) {
-      const respLen = this.responseBuffer.readUInt32LE(0);
-      
-      if (respLen === 0 || respLen > Config.MAX_RESPONSE_SIZE) {
-        this.pendingResponse.reject(new Error(`Invalid response size: ${respLen}`));
-        this.pendingResponse = null;
-        this.responseBuffer = Buffer.alloc(0);
-        return;
-      }
+    // Try to parse response only if we have a pending request
+    if (!this.pendingResponse || this.responseBuffer.length < 4) {
+      return;
+    }
+    
+    const respLen = this.responseBuffer.readUInt32LE(0);
+    
+    if (respLen === 0 || respLen > Config.MAX_RESPONSE_SIZE) {
+      this.pendingResponse.reject(new Error(`Invalid response size: ${respLen}`));
+      this.pendingResponse = null;
+      this.responseBuffer = Buffer.alloc(0);
+      return;
+    }
 
-      if (this.responseBuffer.length >= 4 + respLen) {
-        const respData = this.responseBuffer.slice(4, 4 + respLen);
-        this.responseBuffer = this.responseBuffer.slice(4 + respLen);
-        
-        try {
-          const decoded = this._decodeResponse(respData);
-          const result = JSON.parse(decoded);
-          this.pendingResponse.resolve(result);
-        } catch (err) {
-          this.pendingResponse.reject(err);
-        }
-        this.pendingResponse = null;
+    if (this.responseBuffer.length >= 4 + respLen) {
+      const respData = this.responseBuffer.slice(4, 4 + respLen);
+      this.responseBuffer = this.responseBuffer.slice(4 + respLen);
+      
+      try {
+        const decoded = this._decodeResponse(respData);
+        const result = JSON.parse(decoded);
+        this.pendingResponse.resolve(result);
+      } catch (err) {
+        this.pendingResponse.reject(err);
       }
+      this.pendingResponse = null;
     }
   }
 
@@ -258,7 +260,27 @@ class PipeClient extends EventEmitter {
   _waitForResponse() {
     return new Promise((resolve, reject) => {
       this.pendingResponse = { resolve, reject };
-      this.responseBuffer = Buffer.alloc(0);
+      
+      // Check if we already have data in buffer (race condition fix)
+      if (this.responseBuffer.length >= 4) {
+        const respLen = this.responseBuffer.readUInt32LE(0);
+        if (respLen > 0 && respLen <= Config.MAX_RESPONSE_SIZE && this.responseBuffer.length >= 4 + respLen) {
+          const respData = this.responseBuffer.slice(4, 4 + respLen);
+          this.responseBuffer = this.responseBuffer.slice(4 + respLen);
+          
+          try {
+            const decoded = this._decodeResponse(respData);
+            const result = JSON.parse(decoded);
+            this.pendingResponse = null;
+            resolve(result);
+            return;
+          } catch (err) {
+            this.pendingResponse = null;
+            reject(err);
+            return;
+          }
+        }
+      }
     });
   }