@codesys/mcp-toolkit 1.4.0 → 1.4.2

package/CHANGELOG.md

@@ -5,14 +5,28 @@ 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.2] - 2025-05-02
+### Fixed
+- Enhanced session communication with better logging and debugging
+- Improved command file handling and error recovery
+- Fixed path handling for session files
+- Added JSON fallback parser for IronPython 2.7
+- Ensured synchronous script execution to prevent conflicts
+- Increased reliability of session status detection
+
+## [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 persistent session management functionality
-- Added support for keeping CODESYS open between commands
-- Created file-based IPC for script execution in existing CODESYS instance
-- Improved session reliability with health checks and automatic recovery
-- Added session timeout after 10 minutes of inactivity
-- Created detailed documentation for session management features
+- 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

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,62 @@
-import sys, os, json, time, traceback
+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
+    try:
+        import simplejson as json
+    except ImportError:
+        print("Neither json nor simplejson could be imported. Check IronPython installation.")
+        # Provide a minimal fallback implementation for basic needs
+        class DummyJson:
+            @staticmethod
+            def load(file_obj):
+                content = file_obj.read()
+                # Very basic parsing for our limited needs
+                if content.strip().startswith("{") and content.strip().endswith("}"):
+                    result = {}
+                    parts = content.strip()[1:-1].split(",")
+                    for part in parts:
+                        if ":" in part:
+                            k, v = part.split(":", 1)
+                            k = k.strip().strip('"\'')
+                            v = v.strip().strip('"\'')
+                            result[k] = v
+                    return result
+                return {}
+                
+            @staticmethod
+            def loads(s):
+                if s.strip().startswith("{") and s.strip().endswith("}"):
+                    result = {}
+                    parts = s.strip()[1:-1].split(",")
+                    for part in parts:
+                        if ":" in part:
+                            k, v = part.split(":", 1)
+                            k = k.strip().strip('"\'')
+                            v = v.strip().strip('"\'')
+                            result[k] = v
+                    return result
+                return {}
+                
+            @staticmethod
+            def dump(obj, file_obj, indent=None):
+                if isinstance(obj, dict):
+                    pairs = []
+                    for k, v in obj.items():
+                        if isinstance(v, str):
+                            pairs.append('"{0}": "{1}"'.format(k, v))
+                        else:
+                            pairs.append('"{0}": {1}'.format(k, v))
+                    file_obj.write("{" + ", ".join(pairs) + "}")
+                else:
+                    file_obj.write(str(obj))
+        
+        json = DummyJson()
+
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -12,17 +68,26 @@ 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")
 
+# Print key information at start
+print("Session status check script starting")
+print("tempdir: {0}".format(tempfile.gettempdir()))
+print("SESSION_DIR: {0}".format(SESSION_DIR))
+print("SESSION_STATE_FILE: {0}".format(SESSION_STATE_FILE))
+print("COMMAND_FILE: {0}".format(COMMAND_FILE))
+print("RESULT_FILE: {0}".format(RESULT_FILE))
+print("SESSION_LOCK_FILE: {0}".format(SESSION_LOCK_FILE))
+
 def check_session_status():
     """Check the status of a CODESYS session"""
     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
@@ -30,7 +95,7 @@ def check_session_status():
             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")
+            print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
             return False
 
         # Check if session is active
@@ -39,7 +104,7 @@ def check_session_status():
         
         # If the status indicates the session is not active, return immediately
         if not active or status in ['stopped', 'error', 'stopping', 'timeout']:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
+            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
@@ -53,10 +118,10 @@ def check_session_status():
                     
                     # If lock file hasn't been updated in 30 seconds, session might be dead
                     if time_diff > 30:
-                        print(f"WARNING: Session lock file is stale by {time_diff:.1f} seconds")
+                        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")
@@ -74,7 +139,7 @@ def check_session_status():
                     
                     # Create ping command
                     ping_command = {
-                        "id": f"ping_{int(time.time())}",
+                        "id": "ping_{0}".format(int(time.time())),
                         "type": "ping",  # Use specific ping command type
                         "timestamp": time.time()
                     }
@@ -110,11 +175,11 @@ def check_session_status():
                                         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"WARNING: Session did not respond to ping within {timeout} seconds")
+                        print("WARNING: Session did not respond to ping within {0} seconds".format(timeout))
                         
                         # Reset command file since ping failed
                         try:
@@ -129,11 +194,11 @@ def check_session_status():
                                 
                             print("Reset command file after failed ping")
                         except Exception as e:
-                            print(f"Error resetting command file: {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
@@ -144,21 +209,21 @@ def check_session_status():
         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)
         
         # 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 = f"{uptime:.0f} seconds" if uptime < 60 else f"{uptime/60:.1f} minutes"
+        uptime_str = "{0:.0f} seconds".format(uptime) if uptime < 60 else "{0:.1f} minutes".format(uptime/60)
         
         if session_active:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is active (ID: {session_id}, Status: {status}, Uptime: {uptime_str}{project_info})")
+            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:
             # 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(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be zombie (ID: {session_id}, Status: {status} but unresponsive)")
+                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'
@@ -170,14 +235,14 @@ def check_session_status():
                         
                     print("Updated session state to error due to unresponsiveness")
                 except Exception as e:
-                    print(f"Error updating session state: {e}")
+                    print("Error updating session state: {0}".format(e))
             else:
-                print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
+                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
 

package/dist/scripts/start_session.py

@@ -1,5 +1,74 @@
-import sys, os, json, time, tempfile, traceback
-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
+    try:
+        import simplejson as json
+    except ImportError:
+        print("Neither json nor simplejson could be imported. Check IronPython installation.")
+        # Provide a minimal fallback implementation for basic needs
+        class DummyJson:
+            @staticmethod
+            def load(file_obj):
+                content = file_obj.read()
+                # Very basic parsing for our limited needs
+                if content.strip().startswith("{") and content.strip().endswith("}"):
+                    result = {}
+                    parts = content.strip()[1:-1].split(",")
+                    for part in parts:
+                        if ":" in part:
+                            k, v = part.split(":", 1)
+                            k = k.strip().strip('"\'')
+                            v = v.strip().strip('"\'')
+                            result[k] = v
+                    return result
+                return {}
+                
+            @staticmethod
+            def loads(s):
+                if s.strip().startswith("{") and s.strip().endswith("}"):
+                    result = {}
+                    parts = s.strip()[1:-1].split(",")
+                    for part in parts:
+                        if ":" in part:
+                            k, v = part.split(":", 1)
+                            k = k.strip().strip('"\'')
+                            v = v.strip().strip('"\'')
+                            result[k] = v
+                    return result
+                return {}
+                
+            @staticmethod
+            def dump(obj, file_obj, indent=None):
+                if isinstance(obj, dict):
+                    pairs = []
+                    for k, v in obj.items():
+                        if isinstance(v, str):
+                            pairs.append('"{0}": "{1}"'.format(k, v))
+                        else:
+                            pairs.append('"{0}": {1}'.format(k, v))
+                    file_obj.write("{" + ", ".join(pairs) + "}")
+                else:
+                    file_obj.write(str(obj))
+        
+        json = DummyJson()
+    
+# Import scriptengine
+try:
+    import scriptengine as script_engine
+    print("Successfully imported scriptengine module")
+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
+
+# Print Python and platform info
+print("Python version: {0}.{1}.{2}".format(sys.version_info[0], sys.version_info[1], sys.version_info[2]))
+print("Platform: {0}".format(sys.platform))
+print("Executable: {0}".format(sys.executable))
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
@@ -25,7 +94,7 @@ def setup_session_dir():
                     try:
                         with open(SESSION_STATE_FILE, 'r') as f:
                             old_state = json.load(f)
-                            print(f"Cleaning up previous session (ID: {old_state.get('session_id', 'unknown')})")
+                            print("Cleaning up previous session (ID: {0})".format(old_state.get('session_id', 'unknown')))
                     except:
                         pass
                 
@@ -36,9 +105,9 @@ def setup_session_dir():
                         if os.path.isfile(filepath):
                             os.unlink(filepath)
                     except Exception as e:
-                        print(f"Error removing file {filepath}: {e}")
+                        print("Error removing file {0}: {1}".format(filepath, e))
             except Exception as e:
-                print(f"Error cleaning up previous session: {e}")
+                print("Error cleaning up previous session: {0}".format(e))
         
         # Create session directory
         if not os.path.exists(SESSION_DIR):
@@ -74,12 +143,12 @@ def setup_session_dir():
         with open(SESSION_LOCK_FILE, 'w') as f:
             f.write(str(time.time()))
         
-        print(f"Session directory setup at: {SESSION_DIR}")
-        print(f"Session ID: {session_id}")
+        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"):
@@ -90,20 +159,29 @@ 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
         try:
@@ -133,7 +211,7 @@ def update_session_state(status="running"):
             
         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
 
@@ -189,13 +267,13 @@ def execute_command(command_data):
             except Exception as e:
                 traceback.print_exc()
                 result["success"] = False
-                result["error"] = f"Error executing script: {str(e)}\n{traceback.format_exc()}"
-                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")
@@ -206,12 +284,12 @@ def execute_command(command_data):
         elif cmd_type == "ping":
             # Simple ping command to check if session is alive
             result["success"] = True
-            result["output"] = f"{SCRIPT_SUCCESS_MARKER}: Session is active"
+            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()
@@ -223,8 +301,8 @@ def execute_command(command_data):
         return {
             "id": command_data.get("id", "unknown"),
             "success": False,
-            "output": f"{SCRIPT_ERROR_MARKER}: Command execution failed",
-            "error": f"{str(e)}\n{traceback.format_exc()}"
+            "output": "{0}: Command execution failed".format(SCRIPT_ERROR_MARKER),
+            "error": "{0}\n{1}".format(str(e), traceback.format_exc())
         }, False
 
 def check_command():
@@ -232,67 +310,128 @@ def check_command():
     try:
         # If command file doesn't exist, return immediately
         if not os.path.exists(COMMAND_FILE):
+            print("Command file does not exist at {0}".format(COMMAND_FILE))
             return False
             
         # Read the command file
         try:
+            print("Reading command file: {0}".format(COMMAND_FILE))
             with open(COMMAND_FILE, 'r') as f:
-                command_data = json.load(f)
-        except json.JSONDecodeError:
-            # If command file is corrupted, reset it
+                file_content = f.read()
+                print("Raw command file content: {0}".format(file_content[:100] if len(file_content) > 100 else file_content))
+                
+                # Check if file is empty
+                if not file_content.strip():
+                    print("Command file is empty, resetting")
+                    command_data = {"status": "ready", "command": None, "timestamp": time.time()}
+                    with open(COMMAND_FILE, 'w') as fw:
+                        json.dump(command_data, fw, indent=2)
+                    return False
+                
+                # Try to parse JSON
+                try:
+                    command_data = json.loads(file_content)
+                except Exception as json_err:
+                    print("Error parsing command file JSON: {0}".format(json_err))
+                    # If command file is corrupted, reset it
+                    command_data = {"status": "ready", "command": None, "timestamp": time.time()}
+                    with open(COMMAND_FILE, 'w') as fw:
+                        json.dump(command_data, fw, indent=2)
+                    return False
+        except Exception as read_err:
+            print("Error reading command file: {0}".format(read_err))
+            # Reset the command file
             command_data = {"status": "ready", "command": None, "timestamp": time.time()}
-            with open(COMMAND_FILE, 'w') as f:
-                json.dump(command_data, f, indent=2)
+            try:
+                with open(COMMAND_FILE, 'w') as fw:
+                    json.dump(command_data, fw, indent=2)
+            except Exception as write_err:
+                print("Error writing reset command file: {0}".format(write_err))
             return False
         
         # Check if there's a new command
-        if command_data.get("status") == "pending" and command_data.get("command"):
-            # Extract the command
-            command = command_data.get("command")
-            
-            # Mark as processing
-            command_data["status"] = "processing"
-            with open(COMMAND_FILE, 'w') as 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)
-            
-            # Write the result
-            result_data = {
-                "status": "complete",
-                "result": result,
-                "timestamp": time.time()
-            }
-            
-            with open(RESULT_FILE, 'w') as f:
-                json.dump(result_data, f, indent=2)
-            
-            # Reset command file
-            command_data = {
-                "status": "ready",
-                "command": None,
-                "timestamp": time.time()
-            }
-            
-            with open(COMMAND_FILE, 'w') as f:
-                json.dump(command_data, f, indent=2)
-            
-            # Update session state to running again
-            if not stop_requested:
-                update_session_state("running")
+        status = command_data.get("status")
+        command = command_data.get("command")
+        
+        print("Command status: {0}".format(status))
+        if command:
+            print("Command found: {0}".format(command.get("type", "unknown")))
             
-            # Update last activity time
-            update_last_activity()
+        if status == "pending" and command:
+            print("Processing pending command...")
             
-            return stop_requested
+            try:
+                # Mark as processing
+                command_data["status"] = "processing"
+                with open(COMMAND_FILE, 'w') as f:
+                    json.dump(command_data, f, indent=2)
+                print("Updated command status to 'processing'")
+                
+                # Update session state to busy
+                update_session_state("busy")
+                
+                # Execute the command
+                print("Executing command: {0}".format(command.get("type", "unknown")))
+                result, stop_requested = execute_command(command)
+                print("Command execution complete, stop_requested: {0}".format(stop_requested))
+                
+                # Write the result
+                result_data = {
+                    "status": "complete",
+                    "result": result,
+                    "timestamp": time.time()
+                }
+                
+                print("Writing result to {0}".format(RESULT_FILE))
+                with open(RESULT_FILE, 'w') as f:
+                    json.dump(result_data, f, indent=2)
+                
+                # Reset command file
+                command_data = {
+                    "status": "ready",
+                    "command": None,
+                    "timestamp": time.time()
+                }
+                
+                print("Resetting command file")
+                with open(COMMAND_FILE, 'w') as 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
+            except Exception as cmd_err:
+                print("Error processing command: {0}".format(cmd_err))
+                traceback.print_exc()
+                
+                # Try to reset the command file
+                try:
+                    command_data = {
+                        "status": "ready",
+                        "command": None,
+                        "timestamp": time.time()
+                    }
+                    with open(COMMAND_FILE, 'w') as f:
+                        json.dump(command_data, f, indent=2)
+                except Exception as reset_err:
+                    print("Error resetting command file: {0}".format(reset_err))
+                
+                # Try to restore session state
+                try:
+                    update_session_state("running")
+                except Exception as state_err:
+                    print("Error updating session state: {0}".format(state_err))
+                    
+                return False
         
         return False
     except Exception as e:
-        print(f"Error checking command: {e}")
+        print("Error in check_command: {0}".format(e))
         traceback.print_exc()
         return False
 
@@ -308,7 +447,7 @@ def update_last_activity():
             with open(SESSION_STATE_FILE, 'w') as f:
                 json.dump(state, f, indent=2)
     except Exception as e:
-        print(f"Error updating last activity: {e}")
+        print("Error updating last activity: {0}".format(e))
 
 def check_inactivity_timeout():
     """Check if session has been inactive for too long"""
@@ -321,31 +460,73 @@ def check_inactivity_timeout():
             current_time = time.time()
             
             if (current_time - last_activity) > MAX_INACTIVITY_TIME:
-                print(f"Session inactive for {current_time - last_activity:.1f} seconds, shutting down")
+                print("Session inactive for {0:.1f} seconds, shutting down".format(current_time - last_activity))
                 return True
         
         return False
     except Exception as e:
-        print(f"Error checking inactivity timeout: {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()
+    loop_count = 0
+    last_heartbeat = 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))
+    print("Session lock file: {0}".format(SESSION_LOCK_FILE))
+    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))
+    
+    # Set up initial session state files
+    try:
+        # Create initial command file if it doesn't exist
+        if not os.path.exists(COMMAND_FILE):
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump({
+                    "status": "ready",
+                    "command": None,
+                    "timestamp": time.time()
+                }, f, indent=2)
+            print("Created initial command file")
+            
+        # Create initial result file if it doesn't exist
+        if not os.path.exists(RESULT_FILE):
+            with open(RESULT_FILE, 'w') as f:
+                json.dump({
+                    "status": "none",
+                    "result": None,
+                    "timestamp": time.time()
+                }, f, indent=2)
+            print("Created initial result file")
+    except Exception as setup_err:
+        print("Error setting up initial files: {0}".format(setup_err))
+        traceback.print_exc()
     
     while not stop_requested:
         try:
+            loop_count += 1
+            current_time = time.time()
+            
             # Update session lock file to indicate we're alive
             with open(SESSION_LOCK_FILE, 'w') as f:
-                f.write(str(time.time()))
+                f.write(str(current_time))
+            
+            # Print heartbeat message every 60 seconds
+            if current_time - last_heartbeat > 60:
+                print("Command loop heartbeat - still alive (iteration {0})".format(loop_count))
+                last_heartbeat = current_time
             
             # Check for new commands
+            print("Checking for commands...")
             stop_requested = check_command()
+            if stop_requested:
+                print("Stop was requested by a command")
             
             # Check for inactivity timeout
             if check_inactivity_timeout():
@@ -354,8 +535,8 @@ def command_loop():
                 stop_requested = True
                 
             # Periodically update session state (every 30 seconds)
-            current_time = time.time()
             if (current_time - last_state_update) > 30:
+                print("Periodic session state update")
                 update_session_state()
                 last_state_update = current_time
             
@@ -363,12 +544,12 @@ def command_loop():
             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
+            # Sleep for a bit before retrying
             time.sleep(POLL_INTERVAL)
     
-    print("Command loop stopped.")
+    print("Command loop stopped after {0} iterations".format(loop_count))
 
 # Main script
 def main():
@@ -381,17 +562,17 @@ 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)
 

package/dist/scripts/stop_session.py

@@ -1,6 +1,67 @@
-import sys, os, json, time, traceback
+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
+    try:
+        import simplejson as json
+    except ImportError:
+        print("Neither json nor simplejson could be imported. Check IronPython installation.")
+        # Provide a minimal fallback implementation for basic needs
+        class DummyJson:
+            @staticmethod
+            def load(file_obj):
+                content = file_obj.read()
+                # Very basic parsing for our limited needs
+                if content.strip().startswith("{") and content.strip().endswith("}"):
+                    result = {}
+                    parts = content.strip()[1:-1].split(",")
+                    for part in parts:
+                        if ":" in part:
+                            k, v = part.split(":", 1)
+                            k = k.strip().strip('"\'')
+                            v = v.strip().strip('"\'')
+                            result[k] = v
+                    return result
+                return {}
+                
+            @staticmethod
+            def loads(s):
+                if s.strip().startswith("{") and s.strip().endswith("}"):
+                    result = {}
+                    parts = s.strip()[1:-1].split(",")
+                    for part in parts:
+                        if ":" in part:
+                            k, v = part.split(":", 1)
+                            k = k.strip().strip('"\'')
+                            v = v.strip().strip('"\'')
+                            result[k] = v
+                    return result
+                return {}
+                
+            @staticmethod
+            def dump(obj, file_obj, indent=None):
+                if isinstance(obj, dict):
+                    pairs = []
+                    for k, v in obj.items():
+                        if isinstance(v, str):
+                            pairs.append('"{0}": "{1}"'.format(k, v))
+                        else:
+                            pairs.append('"{0}": {1}'.format(k, v))
+                    file_obj.write("{" + ", ".join(pairs) + "}")
+                else:
+                    file_obj.write(str(obj))
+        
+        json = DummyJson()
+
+# Print Python and platform info
+print("Python version: {0}.{1}.{2}".format(sys.version_info[0], sys.version_info[1], sys.version_info[2]))
+print("Platform: {0}".format(sys.platform))
+print("Executable: {0}".format(sys.executable))
+
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -12,17 +73,26 @@ 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")
 
+# Print key information at start
+print("Session stop script starting")
+print("tempdir: {0}".format(tempfile.gettempdir()))
+print("SESSION_DIR: {0}".format(SESSION_DIR))
+print("SESSION_STATE_FILE: {0}".format(SESSION_STATE_FILE))
+print("COMMAND_FILE: {0}".format(COMMAND_FILE))
+print("RESULT_FILE: {0}".format(RESULT_FILE))
+print("SESSION_LOCK_FILE: {0}".format(SESSION_LOCK_FILE))
+
 def stop_session():
     """Stop a running CODESYS 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
@@ -30,17 +100,17 @@ def stop_session():
             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")
+            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(f"{SCRIPT_SUCCESS_MARKER}: Session is already 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
@@ -52,13 +122,13 @@ def stop_session():
                     
                 current_time = time.time()
                 if (current_time - lock_time) > 30:
-                    print(f"WARNING: Session lock file is stale ({current_time - lock_time:.1f} seconds old). Session may have crashed.")
+                    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(f"Warning: Error reading lock file: {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()
         }
@@ -73,7 +143,7 @@ def stop_session():
         with open(COMMAND_FILE, 'w') as 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 = 15  # seconds (increased timeout for more reliability)
@@ -94,10 +164,10 @@ 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 regardless of result
@@ -112,15 +182,15 @@ def stop_session():
             with open(SESSION_STATE_FILE, 'w') as f:
                 json.dump(session_state, f, indent=2)
         except Exception as e:
-            print(f"Warning: Failed to update session state file: {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:
             # If we didn't get a response, the session may be hung
             # Force a cleanup by removing session files
-            print(f"Warning: Session did not respond to stop command. Forcing cleanup.")
+            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):
@@ -129,16 +199,16 @@ def stop_session():
                         if os.path.isfile(filepath):
                             os.unlink(filepath)
                     except Exception as e:
-                        print(f"Error removing file {filepath}: {e}")
+                        print("Error removing file {0}: {1}".format(filepath, e))
                 
-                print(f"{SCRIPT_SUCCESS_MARKER}: Session files cleaned up forcefully")
+                print("{0}: Session files cleaned up forcefully".format(SCRIPT_SUCCESS_MARKER))
                 return True
             except Exception as e:
-                print(f"{SCRIPT_ERROR_MARKER}: Failed to force cleanup - {str(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
 

package/dist/sessionManager.js

@@ -122,7 +122,8 @@ class CodesysSessionManager extends events_1.EventEmitter {
         this.idleTimeoutMs = idleTimeoutMs;
         this.sessionId = (0, uuid_1.v4)();
         // Set up session directory and files
-        this.sessionDir = path.join(SESSION_DIR, this.sessionId);
+        // IMPORTANT: Don't use a subdirectory - Python scripts expect files directly in SESSION_DIR
+        this.sessionDir = SESSION_DIR;
         this.commandFilePath = path.join(this.sessionDir, COMMAND_FILE);
         this.resultFilePath = path.join(this.sessionDir, RESULT_FILE);
         this.stateFilePath = path.join(this.sessionDir, STATE_FILE);
@@ -442,16 +443,27 @@ class CodesysSessionManager extends events_1.EventEmitter {
                         }, 2000); // Give it 2 seconds to terminate gracefully
                     });
                 }
-                // Clean up session directory
+                // Clean up session files (not entire directory)
                 try {
                     if (fs.existsSync(this.sessionDir)) {
-                        console.error(`SESSION_MANAGER: Cleaning up session directory: ${this.sessionDir}`);
-                        // Use recursive: true once we're on Node.js 14+
-                        this.recursiveRemoveDir(this.sessionDir);
+                        console.error(`SESSION_MANAGER: Cleaning up session files in: ${this.sessionDir}`);
+                        // Remove only the session-related files, not the entire directory
+                        const filesToRemove = [
+                            this.commandFilePath,
+                            this.resultFilePath,
+                            this.stateFilePath,
+                            this.lockFilePath
+                        ];
+                        for (const filePath of filesToRemove) {
+                            if (fs.existsSync(filePath)) {
+                                fs.unlinkSync(filePath);
+                                console.error(`SESSION_MANAGER: Removed session file: ${filePath}`);
+                            }
+                        }
                     }
                 }
                 catch (error) {
-                    console.error(`SESSION_MANAGER: Error cleaning up session directory: ${error}`);
+                    console.error(`SESSION_MANAGER: Error cleaning up session files: ${error}`);
                 }
                 this.codesysProcess = null;
                 this.sessionState = exports.SessionState.STOPPED;
@@ -524,8 +536,6 @@ class CodesysSessionManager extends events_1.EventEmitter {
             }
             // Reset idle timeout since we're about to do work
             this.resetIdleTimeout();
-            // Mark the session as busy
-            this.sessionState = exports.SessionState.BUSY;
             // Check if the command file exists
             if (!fs.existsSync(this.commandFilePath)) {
                 this.sessionState = exports.SessionState.ERROR;
@@ -536,6 +546,50 @@ class CodesysSessionManager extends events_1.EventEmitter {
                 this.sessionState = exports.SessionState.ERROR;
                 throw new Error(`Result file not found at ${this.resultFilePath}`);
             }
+            // IMPORTANT: Ensure only one script is executed at a time by checking if other scripts are pending
+            if (this.pendingScripts.size > 0) {
+                console.error(`SESSION_MANAGER: Waiting for ${this.pendingScripts.size} pending scripts to complete before executing new script`);
+                // Wait for all pending scripts to complete
+                yield new Promise((resolve) => {
+                    const checkInterval = setInterval(() => {
+                        if (this.pendingScripts.size === 0) {
+                            clearInterval(checkInterval);
+                            resolve();
+                        }
+                    }, 100);
+                });
+                console.error('SESSION_MANAGER: All pending scripts completed, proceeding with new script execution');
+            }
+            // Mark the session as busy
+            this.sessionState = exports.SessionState.BUSY;
+            // Read current command file to ensure we're not overwriting an in-progress command
+            try {
+                const currentCommandData = JSON.parse(fs.readFileSync(this.commandFilePath, 'utf8'));
+                if (currentCommandData.status === 'pending' || currentCommandData.status === 'processing') {
+                    console.error(`SESSION_MANAGER: Found pending command in file, waiting for it to complete`);
+                    // Wait for the command to complete (status to be 'ready')
+                    yield new Promise((resolve) => {
+                        const checkInterval = setInterval(() => {
+                            try {
+                                const checkData = JSON.parse(fs.readFileSync(this.commandFilePath, 'utf8'));
+                                if (checkData.status === 'ready') {
+                                    clearInterval(checkInterval);
+                                    resolve();
+                                }
+                            }
+                            catch (err) {
+                                // If we can't read the file, just continue
+                                console.error(`SESSION_MANAGER: Error reading command file during wait: ${err}`);
+                            }
+                        }, 100);
+                    });
+                    console.error('SESSION_MANAGER: Previous command completed, proceeding with new command');
+                }
+            }
+            catch (err) {
+                console.error(`SESSION_MANAGER: Error reading current command file: ${err}`);
+                // If we can't read the file, we'll try to proceed anyway
+            }
             // Return a promise that will be resolved when script execution completes
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 try {
@@ -584,7 +638,8 @@ class CodesysSessionManager extends events_1.EventEmitter {
                         timestamp: Date.now()
                     };
                     // Send the command by writing to the command file
-                    fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData));
+                    console.error(`SESSION_MANAGER: Writing command to file ${this.commandFilePath}`);
+                    fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData, null, 2));
                     console.error(`SESSION_MANAGER: Command written to file`);
                     // Start reading the result file
                     this.readResultFile(scriptId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codesys/mcp-toolkit",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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()