@codesys/mcp-toolkit 1.4.1 → 1.4.3

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.3] - 2025-05-02
+### Fixed
+- Fixed "Cannot import name redirect_stdout" error in session script execution
+- Replaced contextlib.redirect_stdout/redirect_stderr with direct sys.stdout/stderr assignment for IronPython 2.7 compatibility
+- Improved StringIO import handling for better Python 2/3 compatibility
+
+## [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

package/dist/scripts/session_status.py

@@ -6,7 +6,56 @@ try:
     import json
 except ImportError:
     # For IronPython 2.7, we need to use simplejson instead
-    import simplejson as json
+    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"
@@ -19,6 +68,15 @@ 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:

package/dist/scripts/start_session.py

@@ -5,16 +5,71 @@ try:
     import json
 except ImportError:
     # For IronPython 2.7, we need to use simplejson instead
-    import simplejson as json
+    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"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -181,16 +236,31 @@ def execute_command(command_data):
                 # 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
+                # Capture output by temporarily replacing stdout/stderr
+                # Use custom approach compatible with IronPython 2.7
+                try:
+                    import StringIO as io_module  # Python 2.x
+                except ImportError:
+                    import io as io_module  # Python 3.x
+                
+                stdout_buffer = io_module.StringIO()
+                stderr_buffer = io_module.StringIO()
                 
-                stdout_buffer = io.StringIO()
-                stderr_buffer = io.StringIO()
+                # Save original stdout and stderr
+                old_stdout = sys.stdout
+                old_stderr = sys.stderr
                 
-                with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+                # Replace with our buffers
+                sys.stdout = stdout_buffer
+                sys.stderr = stderr_buffer
+                
+                try:
                     # Execute the script
                     exec(script, local_globals)
+                finally:
+                    # Restore original stdout and stderr
+                    sys.stdout = old_stdout
+                    sys.stderr = old_stderr
                 
                 # Get the captured output
                 stdout_output = stdout_buffer.getvalue()
@@ -255,67 +325,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("Error checking command: {0}".format(e))
+        print("Error in check_command: {0}".format(e))
         traceback.print_exc()
         return False
 
@@ -356,19 +487,61 @@ 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("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():
@@ -377,8 +550,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
             
@@ -388,10 +561,10 @@ def command_loop():
         except Exception as 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():

package/dist/scripts/stop_session.py

@@ -6,7 +6,61 @@ try:
     import json
 except ImportError:
     # For IronPython 2.7, we need to use simplejson instead
-    import simplejson as json
+    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"
@@ -19,6 +73,15 @@ 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:

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.1",
+  "version": "1.4.3",
   "description": "Model Context Protocol (MCP) server for CODESYS automation platform",
   "main": "dist/server.js",
   "bin": {