@codesys/mcp-toolkit 1.5.6 → 1.5.8

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.8] - 2025-05-02
+### Fixed
+- Fixed null reference error when accessing sessionManager.getState() with --no-session flag
+- Added proper null checks for session manager in session_status, start_session, and stop_session tools
+- Improved error messages when trying to use session management tools with --no-session flag
+
+## [1.5.7] - 2025-05-02
+### Fixed
+- Added safety timeout to session scripts to prevent CODESYS UI hanging
+- Improved session detection and management to handle zombie sessions
+- Enhanced session cleanup in stop_session.py with more robust error handling
+- Added maximum session runtime (8 hours) to prevent infinite hanging
+- Improved error detection and recovery in session management scripts
+
 ## [1.5.6] - 2025-05-02
 ### Fixed
 - Fixed session manager null reference error in interop.ts

package/dist/scripts/session_status.py

@@ -97,6 +97,9 @@ def check_session_status():
         except json.JSONDecodeError:
             print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
             return False
+        except Exception as e:
+            print("{0}: Error reading session state file: {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+            return False
 
         # Check if session is active
         active = session_state.get('active', False)
@@ -107,13 +110,36 @@ def check_session_status():
             print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
             return False
         
+        # Check for session running too long (> 8 hours)
+        start_time = session_state.get('start_time', 0)
+        current_time = time.time()
+        uptime = current_time - start_time if start_time else 0
+        max_allowed_uptime = 60 * 60 * 8  # 8 hours in seconds
+        
+        if uptime > max_allowed_uptime:
+            print("WARNING: Session has been running for {0:.1f} hours, exceeding the 8-hour safety limit".format(uptime / 3600))
+            
+            # Update session state to indicate timeout due to excessive runtime
+            try:
+                session_state['status'] = 'timeout'
+                session_state['active'] = False
+                session_state['error_reason'] = 'Maximum runtime exceeded'
+                
+                with open(SESSION_STATE_FILE, 'w') as f:
+                    json.dump(session_state, f, indent=2)
+                    
+                print("Updated session state to timeout due to excessive runtime")
+                print("{0}: Session is not active (exceeded maximum runtime)".format(SCRIPT_SUCCESS_MARKER))
+                return False
+            except Exception as e:
+                print("Error updating session state: {0}".format(e))
+        
         # Check session lock file to see if it's been updated recently
         lock_is_stale = False
         if os.path.exists(SESSION_LOCK_FILE):
             try:
                 with open(SESSION_LOCK_FILE, 'r') as f:
                     lock_time = float(f.read().strip())
-                    current_time = time.time()
                     time_diff = current_time - lock_time
                     
                     # If lock file hasn't been updated in 30 seconds, session might be dead
@@ -213,9 +239,10 @@ def check_session_status():
         
         # Include session info
         session_id = session_state.get('session_id', 'Unknown')
-        start_time = session_state.get('start_time', 0)
-        uptime = time.time() - start_time if start_time else 0
-        uptime_str = "{0:.0f} seconds".format(uptime) if uptime < 60 else "{0:.1f} minutes".format(uptime/60)
+        uptime_str = "{0:.0f} seconds".format(uptime) if uptime < 60 else (
+            "{0:.1f} minutes".format(uptime/60) if uptime < 3600 else 
+            "{0:.1f} hours".format(uptime/3600)
+        )
         
         if session_active:
             print("{0}: Session is active (ID: {1}, Status: {2}, Uptime: {3}{4})".format(SCRIPT_SUCCESS_MARKER, session_id, status, uptime_str, project_info))

package/dist/scripts/start_session.py

@@ -648,6 +648,11 @@ def command_loop():
     last_state_update = time.time()
     loop_count = 0
     last_heartbeat = time.time()
+    start_time = time.time()
+    error_count = 0  # Track consecutive errors
+    
+    # Maximum session runtime to prevent infinite hanging (8 hours)
+    max_session_runtime = 60 * 60 * 8
     
     print("Starting command loop...")
     print("Command file: {0}".format(COMMAND_FILE))
@@ -656,6 +661,7 @@ def command_loop():
     print("Session state file: {0}".format(SESSION_STATE_FILE))
     print("Poll interval: {0} seconds".format(POLL_INTERVAL))
     print("Max inactivity time: {0} seconds".format(MAX_INACTIVITY_TIME))
+    print("Max session runtime: {0} hours".format(max_session_runtime / 3600))
     sys.stdout.flush()  # Ensure initialization output is visible immediately
     
     # Set up initial session state files
@@ -693,6 +699,17 @@ def command_loop():
             loop_count += 1
             current_time = time.time()
             
+            # Check for absolute maximum session runtime to prevent infinite hanging
+            session_runtime = current_time - start_time
+            if session_runtime > max_session_runtime:
+                print("SAFETY: Maximum session run time of {0} hours reached".format(max_session_runtime / 3600))
+                print("SAFETY: This is to prevent CODESYS from hanging indefinitely")
+                print("SAFETY: Session will now terminate")
+                update_session_state("timeout")
+                sys.stdout.flush()
+                stop_requested = True
+                break
+            
             # Update session lock file to indicate we're alive
             with open(SESSION_LOCK_FILE, 'w') as f:
                 f.write(str(current_time))
@@ -700,6 +717,7 @@ def command_loop():
             # Print heartbeat message every 60 seconds
             if current_time - last_heartbeat > 60:
                 print("Command loop heartbeat - still alive (iteration {0})".format(loop_count))
+                print("Session running for {0:.1f} minutes".format(session_runtime / 60))
                 last_heartbeat = current_time
                 sys.stdout.flush()
             
@@ -723,6 +741,9 @@ def command_loop():
                 last_state_update = current_time
                 sys.stdout.flush()
             
+            # Reset error count on successful iteration
+            error_count = 0
+            
             # Sleep for a bit
             time.sleep(POLL_INTERVAL)
         
@@ -730,8 +751,19 @@ def command_loop():
             print("Error in command loop: {0}".format(e))
             traceback.print_exc()
             sys.stdout.flush()
-            # Sleep for a bit before retrying
-            time.sleep(POLL_INTERVAL)
+            
+            # Increment error count
+            error_count += 1
+            
+            # If we're getting repeated errors, consider breaking the loop
+            if error_count > 10:
+                print("SAFETY: Too many consecutive errors ({0}), stopping session".format(error_count))
+                update_session_state("error")
+                sys.stdout.flush()
+                stop_requested = True
+            else:
+                # Sleep for a bit before retrying
+                time.sleep(POLL_INTERVAL)
     
     print("Command loop stopped after {0} iterations".format(loop_count))
     sys.stdout.flush()

package/dist/scripts/stop_session.py

@@ -85,65 +85,157 @@ print("SESSION_LOCK_FILE: {0}".format(SESSION_LOCK_FILE))
 def stop_session():
     """Stop a running CODESYS session"""
     try:
+        print("Attempting to stop CODESYS session")
+        
         # Check if session directory exists
         if not os.path.exists(SESSION_DIR):
-            print("{0}: No session directory found at {1}".format(SCRIPT_ERROR_MARKER, SESSION_DIR))
-            return False
+            print("{0}: No session directory found at {1}".format(SCRIPT_SUCCESS_MARKER, SESSION_DIR))
+            # Consider this a success since there's no session to stop
+            return True
 
         # Check if session state file exists
         if not os.path.exists(SESSION_STATE_FILE):
-            print("{0}: No session state file found at {1}".format(SCRIPT_ERROR_MARKER, SESSION_STATE_FILE))
-            return False
+            print("{0}: No session state file found at {1}".format(SCRIPT_SUCCESS_MARKER, SESSION_STATE_FILE))
+            # No state file means no active session - clear any other potential session files
+            try:
+                for filename in os.listdir(SESSION_DIR):
+                    filepath = os.path.join(SESSION_DIR, filename)
+                    try:
+                        if os.path.isfile(filepath):
+                            os.unlink(filepath)
+                            print("Removed orphaned session file: {0}".format(filepath))
+                    except Exception as e:
+                        print("Error removing file {0}: {1}".format(filepath, e))
+            except Exception as e:
+                print("Error cleaning session directory: {0}".format(e))
+            
+            return True
 
         # Read session state
         try:
             with open(SESSION_STATE_FILE, 'r') as f:
                 session_state = json.load(f)
-        except json.JSONDecodeError:
-            print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
-            return False
-
-        # Check if session is active
-        if not session_state.get('active', False) or session_state.get('status') == 'stopped':
-            print("{0}: Session is already stopped".format(SCRIPT_SUCCESS_MARKER))
+        except Exception as e:
+            print("Error reading session state file: {0}".format(e))
+            # Force cleanup regardless of the error
+            try:
+                for filename in os.listdir(SESSION_DIR):
+                    filepath = os.path.join(SESSION_DIR, filename)
+                    try:
+                        if os.path.isfile(filepath):
+                            os.unlink(filepath)
+                            print("Removed session file due to corrupt state: {0}".format(filepath))
+                    except Exception as rm_err:
+                        print("Error removing file {0}: {1}".format(filepath, rm_err))
+            except Exception as dir_err:
+                print("Error cleaning session directory: {0}".format(dir_err))
+            
+            print("{0}: Session files cleaned up forcefully due to corrupt state".format(SCRIPT_SUCCESS_MARKER))
             return True
 
-        # Check if command file exists
-        if not os.path.exists(COMMAND_FILE):
-            print("{0}: Command file not found at {1}".format(SCRIPT_ERROR_MARKER, COMMAND_FILE))
-            return False
+        # Check if session is already marked as inactive
+        if not session_state.get('active', False) or session_state.get('status') in ['stopped', 'error', 'timeout']:
+            print("{0}: Session is already marked as {1}".format(
+                SCRIPT_SUCCESS_MARKER, session_state.get('status', 'inactive')))
+            
+            # Remove session files to ensure a clean state
+            try:
+                for filename in os.listdir(SESSION_DIR):
+                    filepath = os.path.join(SESSION_DIR, filename)
+                    try:
+                        if os.path.isfile(filepath):
+                            os.unlink(filepath)
+                            print("Removed session file for cleanup: {0}".format(filepath))
+                    except Exception as e:
+                        print("Error removing file {0}: {1}".format(filepath, e))
+            except Exception as e:
+                print("Error cleaning session directory: {0}".format(e))
+            
+            return True
 
-        # Try to read the lock file to check if session is still alive
-        lock_time = 0
+        # Get lock file age to check if session is responsive
+        lock_is_stale = False
+        current_time = time.time()
+        
         try:
             if os.path.exists(SESSION_LOCK_FILE):
                 with open(SESSION_LOCK_FILE, 'r') as f:
                     lock_time = float(f.read().strip())
+                    lock_age = current_time - lock_time
                     
-                current_time = time.time()
-                if (current_time - lock_time) > 30:
-                    print("WARNING: Session lock file is stale ({0:.1f} seconds old). Session may have crashed.".format(current_time - lock_time))
+                if lock_age > 30:
+                    print("WARNING: Session lock file is stale ({0:.1f} seconds old). Session may have crashed.".format(lock_age))
+                    lock_is_stale = True
+            else:
+                print("WARNING: Session lock file not found. Session may have crashed.")
+                lock_is_stale = True
         except Exception as e:
             print("Warning: Error reading lock file: {0}".format(e))
+            lock_is_stale = True
 
-        # Create stop command
-        stop_command = {
-            "id": "stop_{0}".format(int(time.time())),
-            "type": "stop",
-            "timestamp": time.time()
-        }
+        # If the command file doesn't exist, we have a zombie session
+        if not os.path.exists(COMMAND_FILE):
+            print("WARNING: Command file not found. Session is in a zombie state.")
+            lock_is_stale = True
+        
+        # If the session appears to be a zombie (stale lock), don't try to send a command
+        # Just force cleanup immediately
+        if lock_is_stale:
+            print("Session appears to be unresponsive. Skipping command and forcing cleanup.")
+            try:
+                # Update state file first
+                try:
+                    session_state['active'] = False
+                    session_state['status'] = "error"
+                    session_state['end_time'] = current_time
+                    session_state['error_reason'] = "Unresponsive session, forced cleanup"
+                    
+                    with open(SESSION_STATE_FILE, 'w') as f:
+                        json.dump(session_state, f, indent=2)
+                        print("Updated session state to error before cleanup")
+                except Exception as state_err:
+                    print("Warning: Failed to update session state file: {0}".format(state_err))
+                
+                # Remove all session files
+                for filename in os.listdir(SESSION_DIR):
+                    filepath = os.path.join(SESSION_DIR, filename)
+                    try:
+                        if os.path.isfile(filepath):
+                            os.unlink(filepath)
+                            print("Removed zombie session file: {0}".format(filepath))
+                    except Exception as e:
+                        print("Error removing file {0}: {1}".format(filepath, e))
+                
+                print("{0}: Zombie session files cleaned up forcefully".format(SCRIPT_SUCCESS_MARKER))
+                return True
+            except Exception as e:
+                print("{0}: Failed to force cleanup - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+                return False
+        
+        # For responsive sessions, try to send a stop command first
+        try:
+            # Create stop command
+            stop_command = {
+                "id": "stop_{0}".format(int(time.time())),
+                "type": "stop",
+                "timestamp": current_time
+            }
 
-        # Write command to file with pretty-printing
-        command_data = {
-            "status": "pending",
-            "command": stop_command,
-            "timestamp": time.time()
-        }
+            # Write command to file with pretty-printing
+            command_data = {
+                "status": "pending",
+                "command": stop_command,
+                "timestamp": current_time
+            }
 
-        with open(COMMAND_FILE, 'w') as f:
-            json.dump(command_data, f, indent=2)
+            print("Writing stop command to command file: {0}".format(COMMAND_FILE))
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump(command_data, f, indent=2)
 
-        print("Stop command sent to session")
+            print("Stop command sent to session")
+        except Exception as cmd_err:
+            print("Error sending stop command: {0}".format(cmd_err))
+            # Continue to forced cleanup
 
         # Wait for result (with timeout)
         timeout = 15  # seconds (increased timeout for more reliability)
@@ -181,35 +273,47 @@ def stop_session():
 
             with open(SESSION_STATE_FILE, 'w') as f:
                 json.dump(session_state, f, indent=2)
+                print("Updated session state to stopped")
         except Exception as e:
             print("Warning: Failed to update session state file: {0}".format(e))
 
-        if result_received:
-            print("{0}: Session stopped successfully".format(SCRIPT_SUCCESS_MARKER))
+        # Remove all session files for a clean state
+        print("Cleaning up all session files")
+        try:
+            for filename in os.listdir(SESSION_DIR):
+                filepath = os.path.join(SESSION_DIR, filename)
+                try:
+                    if os.path.isfile(filepath):
+                        os.unlink(filepath)
+                        print("Removed session file: {0}".format(filepath))
+                except Exception as e:
+                    print("Error removing file {0}: {1}".format(filepath, e))
+            
+            print("{0}: Session stopped and files cleaned up successfully".format(SCRIPT_SUCCESS_MARKER))
             return True
-        else:
-            # If we didn't get a response, the session may be hung
-            # Force a cleanup by removing session files
-            print("Warning: Session did not respond to stop command. Forcing cleanup.")
-            try:
-                # Try to remove all session files to ensure a clean state for next session
+        except Exception as e:
+            print("{0}: Error during final cleanup - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+            return False
+
+    except Exception as e:
+        print("{0}: Error stopping session - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+        traceback.print_exc()
+        
+        # Try one final desperate cleanup even if everything else failed
+        try:
+            if os.path.exists(SESSION_DIR):
                 for filename in os.listdir(SESSION_DIR):
                     filepath = os.path.join(SESSION_DIR, filename)
                     try:
                         if os.path.isfile(filepath):
                             os.unlink(filepath)
-                    except Exception as e:
-                        print("Error removing file {0}: {1}".format(filepath, e))
-                
-                print("{0}: Session files cleaned up forcefully".format(SCRIPT_SUCCESS_MARKER))
-                return True
-            except Exception as e:
-                print("{0}: Failed to force cleanup - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
-                return False
-
-    except Exception as e:
-        print("{0}: Error stopping session - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
-        traceback.print_exc()
+                            print("Emergency cleanup: Removed session file: {0}".format(filepath))
+                    except Exception:
+                        pass
+                print("Emergency session cleanup attempted after error")
+        except Exception:
+            pass
+            
         return False
 
 # Main script

package/dist/server.js

@@ -177,7 +177,7 @@ function startMcpServer(config) {
         console.error("SERVER.TS: Initializing McpServer...");
         const server = new mcp_js_1.McpServer({
             name: "CODESYS Control MCP Server",
-            version: "1.8.1", // Updated version for session fixes
+            version: "1.8.3", // Updated version with null reference fixes for session management
             capabilities: {
                 resources: { listChanged: true },
                 tools: { listChanged: true }
@@ -800,6 +800,17 @@ function startMcpServer(config) {
         // --- Session Management Tools ---
         server.tool("start_session", "Starts a persistent CODESYS session for improved performance with multiple operations", {}, () => __awaiter(this, void 0, void 0, function* () {
             console.error("Tool call: start_session");
+            // First check if session manager is defined
+            if (!sessionManager) {
+                console.error("Tool call: start_session - session manager is not defined");
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Session management is disabled. Use the toolkit without the --no-session flag to enable session management."
+                        }],
+                    isError: true
+                };
+            }
             try {
                 const currentState = sessionManager.getState();
                 if (currentState === sessionManager_1.SessionState.RUNNING || currentState === sessionManager_1.SessionState.BUSY) {
@@ -842,6 +853,17 @@ function startMcpServer(config) {
         }));
         server.tool("stop_session", "Stops the persistent CODESYS session", {}, () => __awaiter(this, void 0, void 0, function* () {
             console.error("Tool call: stop_session");
+            // First check if session manager is defined
+            if (!sessionManager) {
+                console.error("Tool call: stop_session - session manager is not defined");
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Session management is disabled. No active session to stop."
+                        }],
+                    isError: false // Not an error, as there's no session to stop
+                };
+            }
             try {
                 const currentState = sessionManager.getState();
                 if (currentState === sessionManager_1.SessionState.STOPPED) {
@@ -884,6 +906,17 @@ function startMcpServer(config) {
         }));
         server.tool("session_status", "Returns the status of the CODESYS session", {}, () => __awaiter(this, void 0, void 0, function* () {
             console.error("Tool call: session_status");
+            // First check if session manager is defined
+            if (!sessionManager) {
+                console.error("Tool call: session_status - session manager is not defined");
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Session management is disabled. Status: DISABLED"
+                        }],
+                    isError: false
+                };
+            }
             try {
                 const state = sessionManager.getState();
                 return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codesys/mcp-toolkit",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "description": "Model Context Protocol (MCP) server for CODESYS automation platform",
   "main": "dist/server.js",
   "bin": {