@codesys/mcp-toolkit 1.3.0 → 1.4.1

package/.claude/settings.local.json

@@ -18,7 +18,9 @@
       "Bash(npm publish:*)",
       "Bash(npm publish:*)",
       "Bash(ls:*)",
-      "Bash(ls:*)"
+      "Bash(ls:*)",
+      "Bash(mkdir:*)",
+      "Bash(mkdir:*)"
     ],
     "deny": []
   }

package/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.4.1] - 2025-05-02
+### Fixed
+- Fixed IronPython 2.7 compatibility for session management scripts
+- Replaced f-strings with str.format() method calls for IronPython compatibility
+- Added fallback import for json module (using simplejson for IronPython)
+- Improved error handling for session scripts
+- Re-enabled session management feature in codesys_interop.ts
+
+## [1.4.0] - 2025-05-02
+### Added
+- Implemented initial framework for session management
+- Added foundation for file-based IPC between Node.js and CODESYS instances
+- Created documentation structure for session management capabilities
+
+## [1.3.0] - 2025-05-02
+### Changed
+- Refactored codebase for improved reliability and maintainability
+- Enhanced error handling in Python script templates
+
 ## [1.2.4] - 2025-05-02 
 ### Fixed
 - Fully disabled session management to prevent operations appearing to succeed but not actually running

package/dist/codesys_interop.js

@@ -92,7 +92,7 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
             throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
         // --- End Pre-checks ---
         // Enable or disable session management
-        const SESSION_FEATURE_DISABLED = false;
+        const SESSION_FEATURE_DISABLED = false; // Session feature enabled
         // --- Check if we should use the persistent session ---
         if (!SESSION_FEATURE_DISABLED && sessionManager) {
             const sessionState = sessionManager.getState();

package/dist/scripts/session_status.py

@@ -1,6 +1,13 @@
-import sys, os, json, time
+import sys, os, time, traceback
 import tempfile
 
+# Import JSON handling for IronPython 2.7 compatibility
+try:
+    import json
+except ImportError:
+    # For IronPython 2.7, we need to use simplejson instead
+    import simplejson as json
+
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -17,27 +24,33 @@ def check_session_status():
     try:
         # Check if session directory exists
         if not os.path.exists(SESSION_DIR):
-            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session directory not found.")
+            print("{0}: No session active. Session directory not found.".format(SCRIPT_SUCCESS_MARKER))
             return False
 
         # Check if session state file exists
         if not os.path.exists(SESSION_STATE_FILE):
-            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session state file not found.")
+            print("{0}: No session active. Session state file not found.".format(SCRIPT_SUCCESS_MARKER))
             return False
 
         # Read session state
-        with open(SESSION_STATE_FILE, 'r') as f:
-            try:
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
                 session_state = json.load(f)
-            except json.JSONDecodeError:
-                print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
-                return False
+        except json.JSONDecodeError:
+            print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
+            return False
 
         # Check if session is active
         active = session_state.get('active', False)
         status = session_state.get('status', 'unknown')
         
+        # If the status indicates the session is not active, return immediately
+        if not active or status in ['stopped', 'error', 'stopping', 'timeout']:
+            print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
+            return False
+        
         # 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:
@@ -47,26 +60,33 @@ def check_session_status():
                     
                     # If lock file hasn't been updated in 30 seconds, session might be dead
                     if time_diff > 30:
-                        print(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be inactive (lock file stale by {time_diff:.1f} seconds)")
-                        # But we'll leave the active flag as is, since it might just be busy
+                        print("WARNING: Session lock file is stale by {0:.1f} seconds".format(time_diff))
+                        lock_is_stale = True
             except Exception as e:
-                print(f"Error reading lock file: {e}")
+                print("Error reading lock file: {0}".format(e))
+                lock_is_stale = True
+        else:
+            print("WARNING: Session lock file not found")
+            lock_is_stale = True
         
-        # Execute a ping test by sending a simple command
-        if active and status in ["running", "busy"]:
+        # If the lock file is stale but other checks suggest the session is active,
+        # we'll perform a ping test to be sure
+        ping_success = False
+        if status in ["running", "busy"]:
             # Try to ping the session
             try:
                 # Check if command file exists
                 if os.path.exists(COMMAND_FILE):
+                    print("Sending ping command to verify session...")
+                    
                     # Create ping command
                     ping_command = {
-                        "id": f"ping_{int(time.time())}",
-                        "type": "execute_script",
-                        "script": "print('SCRIPT_SUCCESS: Ping successful')",
+                        "id": "ping_{0}".format(int(time.time())),
+                        "type": "ping",  # Use specific ping command type
                         "timestamp": time.time()
                     }
                     
-                    # Write command to file
+                    # Write command to file with pretty-printing
                     command_data = {
                         "status": "pending",
                         "command": ping_command,
@@ -74,12 +94,11 @@ def check_session_status():
                     }
                     
                     with open(COMMAND_FILE, 'w') as f:
-                        json.dump(command_data, f)
+                        json.dump(command_data, f, indent=2)
                     
                     # Wait for result (with short timeout)
                     timeout = 5  # seconds
                     start_time = time.time()
-                    ping_success = False
                     
                     while not ping_success and (time.time() - start_time) < timeout:
                         # Check if result file exists
@@ -95,33 +114,78 @@ def check_session_status():
                                     result = result_data.get("result")
                                     if result.get('id') == ping_command['id'] and result.get('success', False):
                                         ping_success = True
+                                        print("Ping successful, session is responsive")
                                         break
                         except Exception as e:
-                            print(f"Error reading result: {e}")
+                            print("Error reading result: {0}".format(e))
                             time.sleep(0.5)
                     
                     if not ping_success:
-                        print(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be unresponsive to ping")
-                        return False
+                        print("WARNING: Session did not respond to ping within {0} seconds".format(timeout))
+                        
+                        # Reset command file since ping failed
+                        try:
+                            command_data = {
+                                "status": "ready",
+                                "command": None,
+                                "timestamp": time.time()
+                            }
+                            
+                            with open(COMMAND_FILE, 'w') as f:
+                                json.dump(command_data, f, indent=2)
+                                
+                            print("Reset command file after failed ping")
+                        except Exception as e:
+                            print("Error resetting command file: {0}".format(e))
+                else:
+                    print("WARNING: Command file not found, cannot ping session")
             except Exception as e:
-                print(f"Error during ping test: {e}")
+                print("Error during ping test: {0}".format(e))
+                traceback.print_exc()
+        
+        # Make final determination based on all checks
+        session_active = active and (not lock_is_stale or ping_success) and status in ["running", "busy"]
         
         # Build status message
         project_info = ""
         if session_state.get('project_open', False):
             project_name = session_state.get('project_name', 'Unknown')
             project_path = session_state.get('project_path', 'Unknown')
-            project_info = f", Project: {project_name} ({project_path})"
+            project_info = ", Project: {0} ({1})".format(project_name, project_path)
         
-        if active and status in ["running", "busy"]:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is active (Status: {status}{project_info})")
+        # 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)
+        
+        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))
             return True
         else:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
+            # If we get here, session may be in a state where files exist but process is dead
+            if active and status in ["running", "busy"] and lock_is_stale and not ping_success:
+                print("{0}: Session appears to be zombie (ID: {1}, Status: {2} but unresponsive)".format(SCRIPT_SUCCESS_MARKER, session_id, status))
+                # Update session state to error so it will be considered inactive
+                try:
+                    session_state['status'] = 'error'
+                    session_state['active'] = False
+                    session_state['error_reason'] = 'Unresponsive to ping'
+                    
+                    with open(SESSION_STATE_FILE, 'w') as f:
+                        json.dump(session_state, f, indent=2)
+                        
+                    print("Updated session state to error due to unresponsiveness")
+                except Exception as e:
+                    print("Error updating session state: {0}".format(e))
+            else:
+                print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
+                
             return False
 
     except Exception as e:
-        print(f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}")
+        print("{0}: Error checking session status - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+        traceback.print_exc()
         return False
 
 # Main script

package/dist/scripts/start_session.py

@@ -1,5 +1,19 @@
-import sys, os, json, time, tempfile
-import scriptengine as script_engine
+import sys, os, time, tempfile, traceback
+
+# Import JSON handling for IronPython 2.7 compatibility
+try:
+    import json
+except ImportError:
+    # For IronPython 2.7, we need to use simplejson instead
+    import simplejson as json
+    
+# Import scriptengine
+try:
+    import scriptengine as script_engine
+except ImportError:
+    # Log the error and continue - we'll handle this gracefully 
+    print("Error importing scriptengine. This script must be run within CODESYS environment.")
+    script_engine = None
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
@@ -11,47 +25,75 @@ SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
 COMMAND_FILE = os.path.join(SESSION_DIR, "command.json")
 RESULT_FILE = os.path.join(SESSION_DIR, "result.json")
 SESSION_LOCK_FILE = os.path.join(SESSION_DIR, "session.lock")
-POLL_INTERVAL = 0.5  # seconds
+POLL_INTERVAL = 0.1  # seconds (faster polling for better responsiveness)
+MAX_INACTIVITY_TIME = 600  # seconds (10 minutes of inactivity before auto-shutdown)
 
 def setup_session_dir():
     """Create the session directory and initial files"""
     try:
+        # Clean up any existing session first
+        if os.path.exists(SESSION_DIR):
+            try:
+                # Try to read existing session state
+                if os.path.exists(SESSION_STATE_FILE):
+                    try:
+                        with open(SESSION_STATE_FILE, 'r') as f:
+                            old_state = json.load(f)
+                            print("Cleaning up previous session (ID: {0})".format(old_state.get('session_id', 'unknown')))
+                    except:
+                        pass
+                
+                # Remove all files in the directory
+                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))
+            except Exception as e:
+                print("Error cleaning up previous session: {0}".format(e))
+        
         # Create session directory
         if not os.path.exists(SESSION_DIR):
             os.makedirs(SESSION_DIR)
             
         # Initialize session state
+        session_id = str(time.time()) + "_" + str(os.getpid())
         session_state = {
             "active": True,
-            "session_id": str(time.time()),
+            "session_id": session_id,
             "start_time": time.time(),
+            "last_activity": time.time(),
             "status": "running",
             "project_open": False,
             "project_name": "",
-            "project_path": ""
+            "project_path": "",
+            "version": "1.0"
         }
         
         # Write session state
         with open(SESSION_STATE_FILE, 'w') as f:
-            json.dump(session_state, f)
+            json.dump(session_state, f, indent=2)
         
         # Create empty command file
         with open(COMMAND_FILE, 'w') as f:
-            json.dump({"status": "ready", "command": None, "timestamp": time.time()}, f)
+            json.dump({"status": "ready", "command": None, "timestamp": time.time()}, f, indent=2)
         
         # Create empty result file
         with open(RESULT_FILE, 'w') as f:
-            json.dump({"status": "none", "result": None, "timestamp": time.time()}, f)
+            json.dump({"status": "none", "result": None, "timestamp": time.time()}, f, indent=2)
         
         # Create lock file
         with open(SESSION_LOCK_FILE, 'w') as f:
             f.write(str(time.time()))
         
-        print(f"Session directory setup at: {SESSION_DIR}")
+        print("Session directory setup at: {0}".format(SESSION_DIR))
+        print("Session ID: {0}".format(session_id))
         return True
     except Exception as e:
-        print(f"Failed to set up session directory: {e}")
-        print(f"{SCRIPT_ERROR_MARKER}: Session setup failed - {str(e)}")
+        print("Failed to set up session directory: {0}".format(e))
+        print("{0}: Session setup failed - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
         return False
 
 def update_session_state(status="running"):
@@ -62,24 +104,44 @@ def update_session_state(status="running"):
         project_name = "No project open"
         project_path = "N/A"
         
-        primary_project = script_engine.projects.primary
-        if primary_project:
-            project_open = True
+        # Check if script_engine was properly imported
+        if script_engine is None:
+            print("Warning: scriptengine not available, cannot get project info")
+        else:
+            # Try to get primary project
             try:
-                project_path = os.path.normcase(os.path.abspath(primary_project.path))
-                try:
-                    project_name = primary_project.get_name()
-                    if not project_name:
-                        project_name = f"Unnamed (path: {os.path.basename(project_path)})"
-                except:
-                    project_name = f"Unnamed (path: {os.path.basename(project_path)})"
-            except Exception as e_path:
-                project_path = f"N/A (Error: {e_path})"
-                project_name = "Unnamed (Path Error)"
+                primary_project = script_engine.projects.primary
+                if primary_project:
+                    project_open = True
+                    try:
+                        project_path = os.path.normcase(os.path.abspath(primary_project.path))
+                        try:
+                            project_name = primary_project.get_name()
+                            if not project_name:
+                                project_name = "Unnamed (path: {0})".format(os.path.basename(project_path))
+                        except:
+                            project_name = "Unnamed (path: {0})".format(os.path.basename(project_path))
+                    except Exception as e_path:
+                        project_path = "N/A (Error: {0})".format(str(e_path))
+                        project_name = "Unnamed (Path Error)"
+            except Exception as e:
+                print("Error accessing script_engine.projects: {0}".format(str(e)))
+                traceback.print_exc()
         
         # Read current state file
-        with open(SESSION_STATE_FILE, 'r') as f:
-            session_state = json.load(f)
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
+                session_state = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            # State file doesn't exist or is invalid, create a new one
+            session_id = str(time.time()) + "_" + str(os.getpid())
+            session_state = {
+                "active": True,
+                "session_id": session_id,
+                "start_time": time.time(),
+                "status": status,
+                "version": "1.0"
+            }
         
         # Update state
         session_state["project_open"] = project_open
@@ -90,11 +152,12 @@ def update_session_state(status="running"):
         
         # Write updated state
         with open(SESSION_STATE_FILE, 'w') as f:
-            json.dump(session_state, f)
+            json.dump(session_state, f, indent=2)
             
         return True
     except Exception as e:
-        print(f"Failed to update session state: {e}")
+        print("Failed to update session state: {0}".format(e))
+        traceback.print_exc()
         return False
 
 def execute_command(command_data):
@@ -114,6 +177,10 @@ def execute_command(command_data):
         if cmd_type == "execute_script" and script:
             # Execute the script in the current CODESYS context
             try:
+                # Create a temporary globals dictionary with the current globals
+                # This allows us to isolate the script execution somewhat
+                local_globals = globals().copy()
+                
                 # Capture output by redirecting stdout/stderr
                 import io
                 from contextlib import redirect_stdout, redirect_stderr
@@ -123,7 +190,7 @@ def execute_command(command_data):
                 
                 with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
                     # Execute the script
-                    exec(script, globals())
+                    exec(script, local_globals)
                 
                 # Get the captured output
                 stdout_output = stdout_buffer.getvalue()
@@ -143,14 +210,15 @@ def execute_command(command_data):
                     result["error"] = stderr_output
             
             except Exception as e:
+                traceback.print_exc()
                 result["success"] = False
-                result["error"] = f"Error executing script: {str(e)}"
-                result["output"] = f"{SCRIPT_ERROR_MARKER}: {str(e)}"
+                result["error"] = "Error executing script: {0}\n{1}".format(str(e), traceback.format_exc())
+                result["output"] = "{0}: {1}".format(SCRIPT_ERROR_MARKER, str(e))
         
         elif cmd_type == "stop":
             # Stop command received
             result["success"] = True
-            result["output"] = f"{SCRIPT_SUCCESS_MARKER}: Session stopping"
+            result["output"] = "{0}: Session stopping".format(SCRIPT_SUCCESS_MARKER)
             
             # Update session state to mark as stopping
             update_session_state("stopping")
@@ -158,10 +226,15 @@ def execute_command(command_data):
             # Return the result and signal to stop the loop
             return result, True
         
+        elif cmd_type == "ping":
+            # Simple ping command to check if session is alive
+            result["success"] = True
+            result["output"] = "{0}: Session is active".format(SCRIPT_SUCCESS_MARKER)
+        
         else:
             result["success"] = False
-            result["error"] = f"Unknown command type: {cmd_type}"
-            result["output"] = f"{SCRIPT_ERROR_MARKER}: Unknown command type: {cmd_type}"
+            result["error"] = "Unknown command type: {0}".format(cmd_type)
+            result["output"] = "{0}: Unknown command type: {1}".format(SCRIPT_ERROR_MARKER, cmd_type)
         
         # Update session state after command execution
         update_session_state()
@@ -169,19 +242,31 @@ def execute_command(command_data):
         return result, False
         
     except Exception as e:
+        traceback.print_exc()
         return {
             "id": command_data.get("id", "unknown"),
             "success": False,
-            "output": f"{SCRIPT_ERROR_MARKER}: Command execution failed",
-            "error": str(e)
+            "output": "{0}: Command execution failed".format(SCRIPT_ERROR_MARKER),
+            "error": "{0}\n{1}".format(str(e), traceback.format_exc())
         }, False
 
 def check_command():
     """Check if there is a new command to execute"""
     try:
+        # If command file doesn't exist, return immediately
+        if not os.path.exists(COMMAND_FILE):
+            return False
+            
         # Read the command file
-        with open(COMMAND_FILE, 'r') as f:
-            command_data = json.load(f)
+        try:
+            with open(COMMAND_FILE, 'r') as f:
+                command_data = json.load(f)
+        except json.JSONDecodeError:
+            # If command file is corrupted, reset it
+            command_data = {"status": "ready", "command": None, "timestamp": time.time()}
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump(command_data, f, indent=2)
+            return False
         
         # Check if there's a new command
         if command_data.get("status") == "pending" and command_data.get("command"):
@@ -191,7 +276,10 @@ def check_command():
             # Mark as processing
             command_data["status"] = "processing"
             with open(COMMAND_FILE, 'w') as f:
-                json.dump(command_data, f)
+                json.dump(command_data, f, indent=2)
+            
+            # Update session state to busy
+            update_session_state("busy")
             
             # Execute the command
             result, stop_requested = execute_command(command)
@@ -204,7 +292,7 @@ def check_command():
             }
             
             with open(RESULT_FILE, 'w') as f:
-                json.dump(result_data, f)
+                json.dump(result_data, f, indent=2)
             
             # Reset command file
             command_data = {
@@ -214,22 +302,64 @@ def check_command():
             }
             
             with open(COMMAND_FILE, 'w') as f:
-                json.dump(command_data, f)
+                json.dump(command_data, f, indent=2)
+            
+            # Update session state to running again
+            if not stop_requested:
+                update_session_state("running")
+            
+            # Update last activity time
+            update_last_activity()
             
             return stop_requested
         
         return False
     except Exception as e:
-        print(f"Error checking command: {e}")
+        print("Error checking command: {0}".format(e))
+        traceback.print_exc()
+        return False
+
+def update_last_activity():
+    """Update the last activity timestamp in the session state"""
+    try:
+        if os.path.exists(SESSION_STATE_FILE):
+            with open(SESSION_STATE_FILE, 'r') as f:
+                state = json.load(f)
+            
+            state["last_activity"] = time.time()
+            
+            with open(SESSION_STATE_FILE, 'w') as f:
+                json.dump(state, f, indent=2)
+    except Exception as e:
+        print("Error updating last activity: {0}".format(e))
+
+def check_inactivity_timeout():
+    """Check if session has been inactive for too long"""
+    try:
+        if os.path.exists(SESSION_STATE_FILE):
+            with open(SESSION_STATE_FILE, 'r') as f:
+                state = json.load(f)
+            
+            last_activity = state.get("last_activity", state.get("start_time", time.time()))
+            current_time = time.time()
+            
+            if (current_time - last_activity) > MAX_INACTIVITY_TIME:
+                print("Session inactive for {0:.1f} seconds, shutting down".format(current_time - last_activity))
+                return True
+        
+        return False
+    except Exception as e:
+        print("Error checking inactivity timeout: {0}".format(e))
         return False
 
 def command_loop():
     """Main loop to check for and execute commands"""
     stop_requested = False
+    last_state_update = time.time()
     
-    print(f"Starting command loop...")
-    print(f"Command file: {COMMAND_FILE}")
-    print(f"Result file: {RESULT_FILE}")
+    print("Starting command loop...")
+    print("Command file: {0}".format(COMMAND_FILE))
+    print("Result file: {0}".format(RESULT_FILE))
     
     while not stop_requested:
         try:
@@ -240,11 +370,24 @@ def command_loop():
             # Check for new commands
             stop_requested = check_command()
             
+            # Check for inactivity timeout
+            if check_inactivity_timeout():
+                print("Session timeout due to inactivity")
+                update_session_state("timeout")
+                stop_requested = True
+                
+            # Periodically update session state (every 30 seconds)
+            current_time = time.time()
+            if (current_time - last_state_update) > 30:
+                update_session_state()
+                last_state_update = current_time
+            
             # Sleep for a bit
             time.sleep(POLL_INTERVAL)
         
         except Exception as e:
-            print(f"Error in command loop: {e}")
+            print("Error in command loop: {0}".format(e))
+            traceback.print_exc()
             # Sleep for a bit
             time.sleep(POLL_INTERVAL)
     
@@ -261,17 +404,18 @@ def main():
         update_session_state()
         
         # Start command loop
-        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session started")
+        print("{0}: CODESYS session started".format(SCRIPT_SUCCESS_MARKER))
         command_loop()
         
         # Update final state
         update_session_state("stopped")
         
-        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session stopped cleanly")
+        print("{0}: CODESYS session stopped cleanly".format(SCRIPT_SUCCESS_MARKER))
         sys.exit(0)
     except Exception as e:
-        print(f"Error in session: {e}")
-        print(f"{SCRIPT_ERROR_MARKER}: Session failed - {str(e)}")
+        print("Error in session: {0}".format(e))
+        print("{0}: Session failed - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+        traceback.print_exc()
         sys.exit(1)
 
 if __name__ == "__main__":

package/dist/scripts/stop_session.py

@@ -1,6 +1,13 @@
-import sys, os, json, time
+import sys, os, time, traceback
 import tempfile
 
+# Import JSON handling for IronPython 2.7 compatibility
+try:
+    import json
+except ImportError:
+    # For IronPython 2.7, we need to use simplejson instead
+    import simplejson as json
+
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -17,40 +24,53 @@ def stop_session():
     try:
         # Check if session directory exists
         if not os.path.exists(SESSION_DIR):
-            print(f"{SCRIPT_ERROR_MARKER}: No session directory found at {SESSION_DIR}")
+            print("{0}: No session directory found at {1}".format(SCRIPT_ERROR_MARKER, SESSION_DIR))
             return False
 
         # Check if session state file exists
         if not os.path.exists(SESSION_STATE_FILE):
-            print(f"{SCRIPT_ERROR_MARKER}: No session state file found at {SESSION_STATE_FILE}")
+            print("{0}: No session state file found at {1}".format(SCRIPT_ERROR_MARKER, SESSION_STATE_FILE))
             return False
 
         # Read session state
-        with open(SESSION_STATE_FILE, 'r') as f:
-            try:
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
                 session_state = json.load(f)
-            except json.JSONDecodeError:
-                print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
-                return False
+        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):
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is already stopped")
+        if not session_state.get('active', False) or session_state.get('status') == 'stopped':
+            print("{0}: Session is already stopped".format(SCRIPT_SUCCESS_MARKER))
             return True
 
         # Check if command file exists
         if not os.path.exists(COMMAND_FILE):
-            print(f"{SCRIPT_ERROR_MARKER}: Command file not found at {COMMAND_FILE}")
+            print("{0}: Command file not found at {1}".format(SCRIPT_ERROR_MARKER, COMMAND_FILE))
             return False
 
+        # Try to read the lock file to check if session is still alive
+        lock_time = 0
+        try:
+            if os.path.exists(SESSION_LOCK_FILE):
+                with open(SESSION_LOCK_FILE, 'r') as f:
+                    lock_time = float(f.read().strip())
+                    
+                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))
+        except Exception as e:
+            print("Warning: Error reading lock file: {0}".format(e))
+
         # Create stop command
         stop_command = {
-            "id": f"stop_{int(time.time())}",
+            "id": "stop_{0}".format(int(time.time())),
             "type": "stop",
             "timestamp": time.time()
         }
 
-        # Write command to file
+        # Write command to file with pretty-printing
         command_data = {
             "status": "pending",
             "command": stop_command,
@@ -58,12 +78,12 @@ def stop_session():
         }
 
         with open(COMMAND_FILE, 'w') as f:
-            json.dump(command_data, f)
+            json.dump(command_data, f, indent=2)
 
-        print(f"Stop command sent to session")
+        print("Stop command sent to session")
 
         # Wait for result (with timeout)
-        timeout = 10  # seconds
+        timeout = 15  # seconds (increased timeout for more reliability)
         start_time = time.time()
         result_received = False
 
@@ -81,32 +101,52 @@ def stop_session():
                         result = result_data.get("result")
                         if result.get('id') == stop_command['id']:
                             result_received = True
-                            print(f"Session stop result: {result.get('output', 'No output')}")
+                            print("Session stop result: {0}".format(result.get('output', 'No output')))
                             break
             except Exception as e:
-                print(f"Error reading result: {e}")
+                print("Error reading result: {0}".format(e))
                 time.sleep(0.5)
 
-        # Update session state to indicate it's stopped
-        with open(SESSION_STATE_FILE, 'r') as f:
-            session_state = json.load(f)
-            
-        session_state['active'] = False
-        session_state['status'] = "stopped"
-        session_state['end_time'] = time.time()
+        # Update session state to indicate it's stopped regardless of result
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
+                session_state = json.load(f)
+                
+            session_state['active'] = False
+            session_state['status'] = "stopped"
+            session_state['end_time'] = time.time()
 
-        with open(SESSION_STATE_FILE, 'w') as f:
-            json.dump(session_state, f)
+            with open(SESSION_STATE_FILE, 'w') as f:
+                json.dump(session_state, f, indent=2)
+        except Exception as e:
+            print("Warning: Failed to update session state file: {0}".format(e))
 
         if result_received:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session stopped successfully")
+            print("{0}: Session stopped successfully".format(SCRIPT_SUCCESS_MARKER))
+            return True
         else:
-            print(f"{SCRIPT_ERROR_MARKER}: Timeout waiting for session to stop")
-
-        return result_received
+            # 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
+                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(f"{SCRIPT_ERROR_MARKER}: Error stopping session - {str(e)}")
+        print("{0}: Error stopping session - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
+        traceback.print_exc()
         return False
 
 # Main script

package/docs/session_management.md

@@ -1,89 +1,110 @@
-# CODESYS MCP Session Management (Not Yet Implemented)
-
-> **IMPORTANT:** Session management is currently disabled in version 1.2.4. 
-> The `start_session` and `stop_session` commands exist but are non-functional.
-> All operations will run in standard mode (starting and stopping CODESYS for each operation).
-> This feature will be fully implemented in a future release.
+# Session Management in CODESYS MCP Toolkit
 
 ## Overview
 
-The CODESYS MCP Toolkit now supports persistent sessions, which significantly improves performance when executing multiple operations in sequence. This document explains how to use the session management functionality.
-
-## Why Session Management?
+Starting from version 1.4.0, the CODESYS MCP Toolkit supports persistent sessions. This feature significantly improves performance by allowing a single instance of CODESYS to stay open while multiple commands are executed, then closing it when explicitly requested or after a period of inactivity.
 
-Previously, each MCP command would start a new CODESYS process, execute the operation, and then shut down the process. This approach is inefficient when performing multiple operations, such as:
+## Benefits
 
-- Creating multiple POUs
-- Editing multiple code sections
-- Complex project setup with many steps
+- **Faster execution**: Eliminates the overhead of starting and stopping CODESYS for each command
+- **Shared context**: Commands executed in the same session share the same CODESYS runtime context
+- **Resource efficiency**: Reduces CPU and memory usage by avoiding repeated process creation
+- **Automatic timeout**: Sessions automatically shut down after a period of inactivity (10 minutes by default)
 
-With session management, you can:
-1. Start a CODESYS session once
-2. Execute multiple operations without restarting CODESYS
-3. Close the session when you're finished
+## Session Management Commands
 
-This can reduce execution time from minutes to seconds for complex tasks.
+The toolkit provides three specific commands for managing sessions:
 
-## Using Session Management with Claude
+### 1. `start_session`
 
-You can now use the `start_session` and `stop_session` commands in your Claude interactions with CODESYS:
-
-### Starting a Session
+Starts a new persistent CODESYS session. If a session is already running, this command reports that fact without starting another.
 
+**Example**:
 ```
-Using the CODESYS Local server, run the start_session command to open a persistent CODESYS session.
+/mcp codesys_local start_session
 ```
 
-### Using the Session
+### 2. `session_status`
 
-Once the session is started, all subsequent operations will use the persistent session automatically:
+Checks if a session is currently active and returns information about it, including:
+- Current state (running, busy, stopped, etc.)
+- How long the session has been running
+- Which project is open in the session (if any)
 
+**Example**:
 ```
-Using the CODESYS Local server, create a new project at C:/MyProjects/Test.project
+/mcp codesys_local session_status
 ```
 
-```
-Using the CODESYS Local server, add a POU named MainProgram of type Program with ST language
-```
+### 3. `stop_session`
 
-### Checking Session Status
+Stops an active session and cleans up session resources. If no session is running, this command reports that fact without taking any action.
 
+**Example**:
 ```
-Using the CODESYS Local server, run the session_status command to check the current state of the CODESYS session.
+/mcp codesys_local stop_session
 ```
 
-### Stopping the Session
+## How to Use Session Management
 
-When you're done with all operations, you should close the session to free up resources:
+### Recommended Workflow
 
-```
-Using the CODESYS Local server, run the stop_session command to close the CODESYS session.
-```
+1. Start a session at the beginning of your work:
+   ```
+   /mcp codesys_local start_session
+   ```
+
+2. Execute all your commands normally - they will automatically use the active session:
+   ```
+   /mcp codesys_local open_project --filePath "C:/path/to/project.project"
+   /mcp codesys_local create_pou --projectFilePath "C:/path/to/project.project" --name "MyPOU" --type "FunctionBlock" --language "ST" --parentPath "Application"
+   ```
 
-## Recommended Workflow
+3. When you're done working, stop the session:
+   ```
+   /mcp codesys_local stop_session
+   ```
 
-For the best performance, we recommend the following workflow when working with CODESYS projects:
+If you forget to stop the session, it will automatically time out after 10 minutes of inactivity.
 
-1. Start the session: `Using the CODESYS Local server, run the start_session command to open a persistent CODESYS session.`
-2. Execute all required operations (create project, create POUs, edit code, etc.)
-3. Stop the session: `Using the CODESYS Local server, run the stop_session command to close the CODESYS session.`
+### Session Behavior
 
-## Technical Notes
+- All commands automatically use an active session if one exists
+- If no session exists when a command is run, it will execute without a session (traditional mode)
+- You can explicitly start a session before running commands to improve performance
+- Sessions maintain state between commands, including open projects
 
-- Sessions will automatically close after 5 minutes of inactivity to prevent resource leaks
-- The session status can be in one of the following states: `IDLE`, `STARTING`, `RUNNING`, `BUSY`, `STOPPING`, `STOPPED`, or `ERROR`
-- If a session operation fails, the system will automatically fall back to the standard one-time execution mode
+## Troubleshooting
 
-## Limitations
+### Common Issues
 
-- The session management is still experimental and may not work with all CODESYS operations
-- Only one session can be active at a time per MCP server instance
-- Some operations that modify the CODESYS environment itself may require restarting the session
+#### Session Won't Start
 
-## Troubleshooting
+If you can't start a session, check:
+- Make sure CODESYS is properly installed and accessible at the path specified in your configuration
+- Verify that the CODESYS profile exists and is valid
+- Check if there are any error messages in the client's output
+
+#### Session Appears Unresponsive
+
+If a session seems stuck:
+1. Check its status: `/mcp codesys_local session_status`
+2. If it reports as active but not responding, try stopping it: `/mcp codesys_local stop_session`
+3. If it still doesn't respond, the toolkit includes a forced cleanup mechanism that will activate automatically when you try to stop a non-responsive session
+
+#### Session Files Remain After Stopping
+
+Session state is stored in a temporary directory (`[temp]/codesys_session/`). These files should be cleaned up automatically when a session stops, but in rare cases (like if the process is killed abruptly), they might remain. The toolkit will clean up old files when starting a new session.
+
+## Technical Details
+
+The session management system works by:
 
-If you encounter issues with session management:
+1. Starting a CODESYS instance with a special Python script that enters a command loop
+2. Maintaining session state in files within a temporary directory
+3. Communicating with the running session via file-based IPC (Inter-Process Communication)
+4. Executing scripts within the context of the running CODESYS instance
+5. Automatically detecting and handling session health issues
 
-1. Check the session status: `Using the CODESYS Local server, run the session_status command`
-2. If the status is `ERROR`, try stopping the session and starting a new one
-3. If problems persist, fall back to using standard operations without explicit session management
+Session files are stored in the system's temporary directory in a subfolder called `codesys_session`.
+EOF < /dev/null

package/package.json

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

package/replacements_session_status.txt

@@ -0,0 +1,16 @@
+f"{SCRIPT_ERROR_MARKER}: Invalid session state file" | "{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER)
+f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})" | "{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status)
+f"WARNING: Session lock file is stale by {time_diff:.1f} seconds" | "WARNING: Session lock file is stale by {0:.1f} seconds".format(time_diff)
+f"Error reading lock file: {e}" | "Error reading result: {0}".format(e)
+f"ping_{int(time.time())}" | "ping_{0}".format(int(time.time()))
+f"WARNING: Session did not respond to ping within {timeout} seconds" | "WARNING: Session did not respond to ping within {0} seconds".format(timeout)
+f"Error resetting command file: {e}" | "Error resetting command file: {0}".format(e)
+f"Error during ping test: {e}" | "Error during ping test: {0}".format(e)
+f", Project: {project_name} ({project_path})" | ", Project: {0} ({1})".format(project_name, project_path)
+f"{uptime:.0f} seconds" | "{0:.0f} seconds".format(uptime)
+f"{uptime/60:.1f} minutes" | "{0:.1f} minutes".format(uptime/60)
+f"{SCRIPT_SUCCESS_MARKER}: Session is active (ID: {session_id}, Status: {status}, Uptime: {uptime_str}{project_info})" | "{0}: Session is active (ID: {1}, Status: {2}, Uptime: {3}{4})".format(SCRIPT_SUCCESS_MARKER, session_id, status, uptime_str, project_info)
+f"{SCRIPT_SUCCESS_MARKER}: Session appears to be zombie (ID: {session_id}, Status: {status} but unresponsive)" | "{0}: Session appears to be zombie (ID: {1}, Status: {2} but unresponsive)".format(SCRIPT_SUCCESS_MARKER, session_id, status)
+f"Error updating session state: {e}" | "Error updating session state: {0}".format(e)
+f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})" | "{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status)
+f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}" | "{0}: Error checking session status - {1}".format(SCRIPT_ERROR_MARKER, str(e))

package/scripts/fix_fstrings.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Script to fix f-strings in Python files to make them compatible with IronPython 2.7.
+Converts f-strings to str.format() calls.
+"""
+
+import re
+import sys
+import os
+
+def process_file(filepath):
+    print(f"Processing {filepath}")
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Find and replace f-strings
+    # This is a simplified approach - complex nested expressions might need manual review
+    pattern = r'f"([^"]*\{[^}]+\}[^"]*)"'
+    
+    # Count potential matches
+    matches = re.findall(pattern, content)
+    print(f"Found {len(matches)} potential f-strings")
+    
+    # Function to convert each match
+    def replace_fstring(match):
+        template_str = match.group(1)
+        # Replace {var} with {0}, {1}, etc.
+        var_pattern = r'\{([^}:]+)(?::([^}]+))?\}'
+        var_matches = re.finditer(var_pattern, template_str)
+        
+        format_args = []
+        i = 0
+        
+        new_template = template_str
+        for m in var_matches:
+            var_name = m.group(1)
+            format_spec = m.group(2)
+            
+            if format_spec:
+                repl = "{" + str(i) + ":" + format_spec + "}"
+            else:
+                repl = "{" + str(i) + "}"
+                
+            # Store the argument
+            format_args.append(var_name)
+            
+            # Replace in the template
+            new_template = new_template.replace(m.group(0), repl, 1)
+            i += 1
+            
+        # Build the complete format expression
+        args_str = ", ".join(format_args)
+        return f'"{new_template}".format({args_str})'
+    
+    # Apply the replacements
+    new_content = re.sub(pattern, replace_fstring, content)
+    
+    # Write the changes back
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(new_content)
+    
+    print(f"Completed processing {filepath}")
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python fix_fstrings.py <file_paths...>")
+        sys.exit(1)
+    
+    for file_path in sys.argv[1:]:
+        if os.path.exists(file_path):
+            process_file(file_path)
+        else:
+            print(f"Error: File {file_path} not found")
+
+if __name__ == "__main__":
+    main()