@codesys/mcp-toolkit 1.2.4 → 1.3.0

package/dist/scripts/session_status.py

@@ -1,168 +1,132 @@
-import sys, os, json, time, tempfile
+import sys, os, json, time
+import tempfile
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
 
-# Session state file and pipes
+# Session state and command files
 SESSION_DIR = os.path.join(tempfile.gettempdir(), "codesys_session")
 SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
-COMMAND_PIPE = os.path.join(SESSION_DIR, "command_pipe")
-RESULT_PIPE = os.path.join(SESSION_DIR, "result_pipe")
+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")
 
 def check_session_status():
-    """Check the status of a CODESYS session by reading the state file"""
+    """Check the status of a CODESYS session"""
     try:
         # Check if session directory exists
         if not os.path.exists(SESSION_DIR):
-            return {
-                "session_exists": False,
-                "active": False,
-                "message": "No session directory found"
-            }
-            
-        # Check if state file exists
+            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session directory not found.")
+            return False
+
+        # Check if session state file exists
         if not os.path.exists(SESSION_STATE_FILE):
-            return {
-                "session_exists": True,
-                "active": False,
-                "message": "Session directory exists but no state file found"
-            }
-            
-        # Read the state file
+            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session state file not found.")
+            return False
+
+        # Read session state
         with open(SESSION_STATE_FILE, 'r') as f:
-            session_state = json.load(f)
-            
-        # Check if pipes exist
-        pipes_exist = os.path.exists(COMMAND_PIPE) and os.path.exists(RESULT_PIPE)
-        
-        # Get session duration if available
-        start_time = session_state.get("start_time", 0)
-        if start_time > 0:
-            current_time = time.time()
-            duration_secs = int(current_time - start_time)
-            hours, remainder = divmod(duration_secs, 3600)
-            minutes, seconds = divmod(remainder, 60)
-            duration = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-        else:
-            duration = "unknown"
-            
-        # Last update time
-        last_update = session_state.get("last_update", 0)
-        last_update_str = "never"
-        if last_update > 0:
-            seconds_since_update = int(time.time() - last_update)
-            if seconds_since_update < 60:
-                last_update_str = f"{seconds_since_update} seconds ago"
-            elif seconds_since_update < 3600:
-                last_update_str = f"{seconds_since_update // 60} minutes ago"
-            else:
-                last_update_str = f"{seconds_since_update // 3600} hours ago"
-                
-        return {
-            "session_exists": True,
-            "active": session_state.get("active", False),
-            "project_open": session_state.get("project_open", False),
-            "project_name": session_state.get("project_name", "unknown"),
-            "project_path": session_state.get("project_path", "unknown"),
-            "duration": duration,
-            "pipes_exist": pipes_exist,
-            "last_update": last_update_str,
-            "message": "Session information retrieved successfully"
-        }
-    except Exception as e:
-        return {
-            "session_exists": True,
-            "active": False,
-            "error": str(e),
-            "message": f"Error reading session state: {e}"
-        }
+            try:
+                session_state = json.load(f)
+            except json.JSONDecodeError:
+                print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
+                return False
 
-def ping_session():
-    """Attempt to ping the session with a simple command to verify it's responsive"""
-    try:
-        if not os.path.exists(COMMAND_PIPE) or not os.path.exists(RESULT_PIPE):
-            return False
-            
-        ping_command = {
-            "id": f"ping_{time.time()}",
-            "type": "execute_script",
-            "script": "print('SCRIPT_SUCCESS: Ping successful')"
-        }
+        # Check if session is active
+        active = session_state.get('active', False)
+        status = session_state.get('status', 'unknown')
         
-        # Set a timeout for the ping operation
-        timeout = 5  # seconds
-        
-        # Use non-blocking I/O to handle timeouts
-        import select
-        
-        # Send the ping command
-        with open(COMMAND_PIPE, 'w') as cmd_pipe:
-            cmd_pipe.write(json.dumps(ping_command))
+        # Check session lock file to see if it's been updated recently
+        if os.path.exists(SESSION_LOCK_FILE):
+            try:
+                with open(SESSION_LOCK_FILE, 'r') as f:
+                    lock_time = float(f.read().strip())
+                    current_time = time.time()
+                    time_diff = current_time - lock_time
+                    
+                    # If lock file hasn't been updated in 30 seconds, session might be dead
+                    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
+            except Exception as e:
+                print(f"Error reading lock file: {e}")
         
-        # Wait for the result pipe to be readable with timeout
-        res_fd = os.open(RESULT_PIPE, os.O_RDONLY | os.O_NONBLOCK)
-        ready, _, _ = select.select([res_fd], [], [], timeout)
+        # Execute a ping test by sending a simple command
+        if active and status in ["running", "busy"]:
+            # Try to ping the session
+            try:
+                # Check if command file exists
+                if os.path.exists(COMMAND_FILE):
+                    # Create ping command
+                    ping_command = {
+                        "id": f"ping_{int(time.time())}",
+                        "type": "execute_script",
+                        "script": "print('SCRIPT_SUCCESS: Ping successful')",
+                        "timestamp": time.time()
+                    }
+                    
+                    # Write command to file
+                    command_data = {
+                        "status": "pending",
+                        "command": ping_command,
+                        "timestamp": time.time()
+                    }
+                    
+                    with open(COMMAND_FILE, 'w') as f:
+                        json.dump(command_data, f)
+                    
+                    # 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
+                        if not os.path.exists(RESULT_FILE):
+                            time.sleep(0.5)
+                            continue
+                        
+                        try:
+                            with open(RESULT_FILE, 'r') as f:
+                                result_data = json.load(f)
+                                
+                                if result_data.get("status") == "complete" and result_data.get("result"):
+                                    result = result_data.get("result")
+                                    if result.get('id') == ping_command['id'] and result.get('success', False):
+                                        ping_success = True
+                                        break
+                        except Exception as e:
+                            print(f"Error reading result: {e}")
+                            time.sleep(0.5)
+                    
+                    if not ping_success:
+                        print(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be unresponsive to ping")
+                        return False
+            except Exception as e:
+                print(f"Error during ping test: {e}")
         
-        if not ready:
-            os.close(res_fd)
-            return False
-            
-        # Read the result
-        result_json = os.read(res_fd, 4096).decode('utf-8').strip()
-        os.close(res_fd)
+        # 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})"
         
-        if result_json:
-            try:
-                result = json.loads(result_json)
-                return result.get("success", False)
-            except json.JSONDecodeError:
-                return False
+        if active and status in ["running", "busy"]:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is active (Status: {status}{project_info})")
+            return True
         else:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
             return False
-            
-    except Exception as e:
-        print(f"Error pinging session: {e}")
-        return False
 
-def main():
-    try:
-        # Get session status
-        status = check_session_status()
-        
-        # Print status information
-        print(f"Session Exists: {status.get('session_exists', False)}")
-        print(f"Session Active: {status.get('active', False)}")
-        
-        # If session exists, print more details
-        if status.get("session_exists", False):
-            if status.get("active", False):
-                # Try to ping the session
-                is_responsive = ping_session()
-                print(f"Session Responsive: {is_responsive}")
-                
-                # Print project information if available
-                if "project_open" in status:
-                    print(f"Project Open: {status['project_open']}")
-                if "project_name" in status:
-                    print(f"Project Name: {status['project_name']}")
-                if "project_path" in status:
-                    print(f"Project Path: {status['project_path']}")
-                if "duration" in status:
-                    print(f"Session Duration: {status['duration']}")
-                if "last_update" in status:
-                    print(f"Last Activity: {status['last_update']}")
-            else:
-                print("Session is not active (stopped or crashed)")
-                
-        # Print the final result marker
-        print(f"{SCRIPT_SUCCESS_MARKER}: Session status check complete")
-        sys.exit(0)
-        
     except Exception as e:
-        print(f"Error checking session status: {e}")
-        print(f"{SCRIPT_ERROR_MARKER}: {str(e)}")
-        sys.exit(1)
+        print(f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}")
+        return False
 
+# Main script
 if __name__ == "__main__":
-    main()
+    if check_session_status():
+        sys.exit(0)
+    else:
+        sys.exit(1)

package/dist/scripts/start_session.py

@@ -1,49 +1,60 @@
-import sys, os, threading, json, time, tempfile
+import sys, os, json, time, tempfile
 import scriptengine as script_engine
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
 
-# Session state file and pipes
+# Session state and command files
 SESSION_DIR = os.path.join(tempfile.gettempdir(), "codesys_session")
 SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
-COMMAND_PIPE = os.path.join(SESSION_DIR, "command_pipe")
-RESULT_PIPE = os.path.join(SESSION_DIR, "result_pipe")
+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
 
 def setup_session_dir():
-    """Create the session directory and pipes if they don't exist"""
+    """Create the session directory and initial files"""
     try:
         # Create session directory
         if not os.path.exists(SESSION_DIR):
             os.makedirs(SESSION_DIR)
             
-        # Create named pipes if they don't exist
-        if not os.path.exists(COMMAND_PIPE):
-            os.mkfifo(COMMAND_PIPE)
-            
-        if not os.path.exists(RESULT_PIPE):
-            os.mkfifo(RESULT_PIPE)
-            
         # Initialize session state
         session_state = {
             "active": True,
+            "session_id": str(time.time()),
             "start_time": time.time(),
+            "status": "running",
             "project_open": False,
             "project_name": "",
             "project_path": ""
         }
         
+        # Write session state
         with open(SESSION_STATE_FILE, 'w') as f:
             json.dump(session_state, f)
         
+        # Create empty command file
+        with open(COMMAND_FILE, 'w') as f:
+            json.dump({"status": "ready", "command": None, "timestamp": time.time()}, f)
+        
+        # Create empty result file
+        with open(RESULT_FILE, 'w') as f:
+            json.dump({"status": "none", "result": None, "timestamp": time.time()}, f)
+        
+        # Create lock file
+        with open(SESSION_LOCK_FILE, 'w') as f:
+            f.write(str(time.time()))
+        
+        print(f"Session directory setup at: {SESSION_DIR}")
         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)}")
         return False
 
-def update_session_state():
+def update_session_state(status="running"):
     """Update the session state file with current CODESYS state"""
     try:
         # Get current state
@@ -75,6 +86,7 @@ def update_session_state():
         session_state["project_name"] = project_name
         session_state["project_path"] = project_path
         session_state["last_update"] = time.time()
+        session_state["status"] = status
         
         # Write updated state
         with open(SESSION_STATE_FILE, 'w') as f:
@@ -86,9 +98,9 @@ def update_session_state():
         return False
 
 def execute_command(command_data):
-    """Execute a command from the command pipe"""
+    """Execute a command"""
     try:
-        cmd_type = command_data.get("type", "")
+        cmd_type = command_data.get("type", "execute_script")
         script = command_data.get("script", "")
         cmd_id = command_data.get("id", "unknown")
         
@@ -140,15 +152,8 @@ def execute_command(command_data):
             result["success"] = True
             result["output"] = f"{SCRIPT_SUCCESS_MARKER}: Session stopping"
             
-            # Update session state to mark as inactive
-            with open(SESSION_STATE_FILE, 'r') as f:
-                session_state = json.load(f)
-            
-            session_state["active"] = False
-            session_state["end_time"] = time.time()
-            
-            with open(SESSION_STATE_FILE, 'w') as f:
-                json.dump(session_state, f)
+            # Update session state to mark as stopping
+            update_session_state("stopping")
             
             # Return the result and signal to stop the loop
             return result, True
@@ -171,54 +176,84 @@ def execute_command(command_data):
             "error": str(e)
         }, False
 
+def check_command():
+    """Check if there is a new command to execute"""
+    try:
+        # Read the command file
+        with open(COMMAND_FILE, 'r') as f:
+            command_data = json.load(f)
+        
+        # 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)
+            
+            # 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)
+            
+            # Reset command file
+            command_data = {
+                "status": "ready",
+                "command": None,
+                "timestamp": time.time()
+            }
+            
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump(command_data, f)
+            
+            return stop_requested
+        
+        return False
+    except Exception as e:
+        print(f"Error checking command: {e}")
+        return False
+
 def command_loop():
-    """Main loop to listen for and execute commands"""
+    """Main loop to check for and execute commands"""
     stop_requested = False
     
     print(f"Starting command loop...")
-    print(f"Command pipe: {COMMAND_PIPE}")
-    print(f"Result pipe: {RESULT_PIPE}")
+    print(f"Command file: {COMMAND_FILE}")
+    print(f"Result file: {RESULT_FILE}")
     
     while not stop_requested:
         try:
-            # Open the command pipe for reading (blocks until data is available)
-            with open(COMMAND_PIPE, 'r') as cmd_pipe:
-                # Read the command
-                command_json = cmd_pipe.read().strip()
-                
-                if command_json:
-                    print(f"Received command: {command_json[:100]}...")
-                    try:
-                        command_data = json.loads(command_json)
-                        result, stop_requested = execute_command(command_data)
-                        
-                        # Write the result to the result pipe
-                        with open(RESULT_PIPE, 'w') as res_pipe:
-                            res_pipe.write(json.dumps(result))
-                            
-                    except json.JSONDecodeError as e:
-                        # Invalid JSON
-                        print(f"Invalid command JSON: {e}")
-                        error_result = {
-                            "id": "unknown",
-                            "success": False,
-                            "output": f"{SCRIPT_ERROR_MARKER}: Invalid command format",
-                            "error": str(e)
-                        }
-                        with open(RESULT_PIPE, 'w') as res_pipe:
-                            res_pipe.write(json.dumps(error_result))
+            # Update session lock file to indicate we're alive
+            with open(SESSION_LOCK_FILE, 'w') as f:
+                f.write(str(time.time()))
+            
+            # Check for new commands
+            stop_requested = check_command()
+            
+            # Sleep for a bit
+            time.sleep(POLL_INTERVAL)
         
         except Exception as e:
             print(f"Error in command loop: {e}")
-            # Short delay to prevent CPU spinning in case of repeated errors
-            time.sleep(0.5)
+            # Sleep for a bit
+            time.sleep(POLL_INTERVAL)
     
     print("Command loop stopped.")
 
 # Main script
 def main():
     try:
-        # Setup session directory and pipes
+        # Setup session directory and files
         if not setup_session_dir():
             sys.exit(1)
         
@@ -229,6 +264,9 @@ def main():
         print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session started")
         command_loop()
         
+        # Update final state
+        update_session_state("stopped")
+        
         print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session stopped cleanly")
         sys.exit(0)
     except Exception as e:

package/dist/scripts/stop_session.py

@@ -1,94 +1,117 @@
-import sys, os, json, time, tempfile
+import sys, os, json, time
+import tempfile
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
 
-# Session state file and pipes
+# Session state and command files
 SESSION_DIR = os.path.join(tempfile.gettempdir(), "codesys_session")
 SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
-COMMAND_PIPE = os.path.join(SESSION_DIR, "command_pipe")
-RESULT_PIPE = os.path.join(SESSION_DIR, "result_pipe")
+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")
 
-def check_session_active():
-    """Check if a session is active by reading the state 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}")
+            return False
+
+        # Check if session state file exists
         if not os.path.exists(SESSION_STATE_FILE):
-            print(f"No session state file found at {SESSION_STATE_FILE}")
+            print(f"{SCRIPT_ERROR_MARKER}: No session state file found at {SESSION_STATE_FILE}")
             return False
-            
+
+        # Read session state
         with open(SESSION_STATE_FILE, 'r') as f:
-            session_state = json.load(f)
-            
-        return session_state.get("active", False)
-    except Exception as e:
-        print(f"Error checking session state: {e}")
-        return False
+            try:
+                session_state = json.load(f)
+            except json.JSONDecodeError:
+                print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
+                return False
 
-def send_stop_command():
-    """Send the stop command to the running session"""
-    try:
-        if not os.path.exists(COMMAND_PIPE) or not os.path.exists(RESULT_PIPE):
-            print(f"Command or result pipes not found")
+        # Check if session is active
+        if not session_state.get('active', False):
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is already stopped")
+            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}")
             return False
-            
+
+        # Create stop command
         stop_command = {
-            "id": f"stop_{time.time()}",
+            "id": f"stop_{int(time.time())}",
             "type": "stop",
-            "script": ""
+            "timestamp": time.time()
         }
-        
-        # Send the stop command
-        with open(COMMAND_PIPE, 'w') as cmd_pipe:
-            cmd_pipe.write(json.dumps(stop_command))
-            
-        # Wait for the result
-        with open(RESULT_PIPE, 'r') as res_pipe:
-            result_json = res_pipe.read().strip()
-            
-        if result_json:
+
+        # Write command to file
+        command_data = {
+            "status": "pending",
+            "command": stop_command,
+            "timestamp": time.time()
+        }
+
+        with open(COMMAND_FILE, 'w') as f:
+            json.dump(command_data, f)
+
+        print(f"Stop command sent to session")
+
+        # Wait for result (with timeout)
+        timeout = 10  # seconds
+        start_time = time.time()
+        result_received = False
+
+        while not result_received and (time.time() - start_time) < timeout:
+            # Check if result file exists
+            if not os.path.exists(RESULT_FILE):
+                time.sleep(0.5)
+                continue
+
             try:
-                result = json.loads(result_json)
-                return result.get("success", False)
-            except json.JSONDecodeError:
-                print(f"Invalid result JSON: {result_json}")
-                return False
-        else:
-            print("No result received")
-            return False
-            
-    except Exception as e:
-        print(f"Error sending stop command: {e}")
-        return False
+                with open(RESULT_FILE, 'r') as f:
+                    result_data = json.load(f)
+                    
+                    if result_data.get("status") == "complete" and result_data.get("result"):
+                        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')}")
+                            break
+            except Exception as e:
+                print(f"Error reading result: {e}")
+                time.sleep(0.5)
 
-def main():
-    try:
-        # Check if session is active
-        if not check_session_active():
-            print(f"{SCRIPT_SUCCESS_MARKER}: No active session found")
-            sys.exit(0)
-        
-        # Send stop command
-        print("Sending stop command to CODESYS session...")
-        if send_stop_command():
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session stop command sent successfully")
-            
-            # Give the session a moment to clean up
-            time.sleep(1)
+        # Update session state to indicate it's stopped
+        with open(SESSION_STATE_FILE, 'r') as f:
+            session_state = json.load(f)
             
-            # Verify session state has been updated
-            if not check_session_active():
-                print(f"{SCRIPT_SUCCESS_MARKER}: Session stopped successfully")
-            else:
-                print(f"{SCRIPT_SUCCESS_MARKER}: Stop command accepted, but session may still be shutting down")
+        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)
+
+        if result_received:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session stopped successfully")
         else:
-            print(f"{SCRIPT_ERROR_MARKER}: Failed to stop session")
-            sys.exit(1)
-            
+            print(f"{SCRIPT_ERROR_MARKER}: Timeout waiting for session to stop")
+
+        return result_received
+
     except Exception as e:
-        print(f"Error stopping session: {e}")
-        print(f"{SCRIPT_ERROR_MARKER}: {str(e)}")
-        sys.exit(1)
+        print(f"{SCRIPT_ERROR_MARKER}: Error stopping session - {str(e)}")
+        return False
 
+# Main script
 if __name__ == "__main__":
-    main()
+    if stop_session():
+        sys.exit(0)
+    else:
+        sys.exit(1)

package/dist/sessionManager.js

@@ -63,11 +63,12 @@ const scriptLoader_1 = require("./scriptLoader");
 const DEFAULT_SCRIPT_TIMEOUT = 60000; // 60 seconds
 const DEFAULT_SESSION_IDLE_TIMEOUT = 300000; // 5 minutes
 const DEFAULT_SESSION_POLL_INTERVAL = 1000; // 1 second
-// Session directory and pipe names
+// Session directory and file names
 const SESSION_DIR = path.join(os.tmpdir(), 'codesys_session');
-const COMMAND_PIPE = 'command_pipe';
-const RESULT_PIPE = 'result_pipe';
+const COMMAND_FILE = 'command.json';
+const RESULT_FILE = 'result.json';
 const STATE_FILE = 'session_state.json';
+const SESSION_LOCK_FILE = 'session.lock';
 // Define expected success/error markers from the Python scripts
 const SCRIPT_SUCCESS_MARKER = 'SCRIPT_SUCCESS';
 const SCRIPT_ERROR_MARKER = 'SCRIPT_ERROR';
@@ -120,11 +121,12 @@ class CodesysSessionManager extends events_1.EventEmitter {
         this.codesysProfileName = codesysProfileName;
         this.idleTimeoutMs = idleTimeoutMs;
         this.sessionId = (0, uuid_1.v4)();
-        // Set up session directory and pipes
+        // Set up session directory and files
         this.sessionDir = path.join(SESSION_DIR, this.sessionId);
-        this.commandPipePath = path.join(this.sessionDir, COMMAND_PIPE);
-        this.resultPipePath = path.join(this.sessionDir, RESULT_PIPE);
+        this.commandFilePath = path.join(this.sessionDir, COMMAND_FILE);
+        this.resultFilePath = path.join(this.sessionDir, RESULT_FILE);
         this.stateFilePath = path.join(this.sessionDir, STATE_FILE);
+        this.lockFilePath = path.join(this.sessionDir, SESSION_LOCK_FILE);
         // Log status changes through event emitter
         this.on(exports.SESSION_EVENTS.STARTED, () => {
             console.error(`SESSION_MANAGER: Session started successfully`);
@@ -247,8 +249,8 @@ class CodesysSessionManager extends events_1.EventEmitter {
                 // Interpolate parameters
                 const scriptContent = (0, scriptLoader_1.interpolateScript)(scriptTemplate, {
                     SESSION_DIR: this.sessionDir,
-                    COMMAND_PIPE: COMMAND_PIPE,
-                    RESULT_PIPE: RESULT_PIPE,
+                    COMMAND_FILE: COMMAND_FILE,
+                    RESULT_FILE: RESULT_FILE,
                     STATE_FILE: STATE_FILE,
                     SESSION_ID: this.sessionId,
                 });
@@ -319,10 +321,10 @@ class CodesysSessionManager extends events_1.EventEmitter {
             const startTime = Date.now();
             while (Date.now() - startTime < timeoutMs) {
                 try {
-                    // Check if pipes exist
-                    const commandPipeExists = fs.existsSync(this.commandPipePath);
-                    const resultPipeExists = fs.existsSync(this.resultPipePath);
-                    if (commandPipeExists && resultPipeExists) {
+                    // Check if files exist
+                    const commandFileExists = fs.existsSync(this.commandFilePath);
+                    const resultFileExists = fs.existsSync(this.resultFilePath);
+                    if (commandFileExists && resultFileExists) {
                         // Read state file to check if session is ready
                         const stateContent = yield (0, promises_1.readFile)(this.stateFilePath, 'utf8');
                         const stateData = JSON.parse(stateContent);
@@ -366,14 +368,14 @@ class CodesysSessionManager extends events_1.EventEmitter {
             }
             try {
                 // Check if we have a running session
-                if (fs.existsSync(this.sessionDir) && fs.existsSync(this.commandPipePath)) {
+                if (fs.existsSync(this.sessionDir) && fs.existsSync(this.commandFilePath)) {
                     // Load the stop_session script template
                     const scriptTemplate = yield (0, scriptLoader_1.loadScriptTemplate)('stop_session');
                     // Interpolate parameters
                     const scriptContent = (0, scriptLoader_1.interpolateScript)(scriptTemplate, {
                         SESSION_DIR: this.sessionDir,
-                        COMMAND_PIPE: COMMAND_PIPE,
-                        RESULT_PIPE: RESULT_PIPE,
+                        COMMAND_FILE: COMMAND_FILE,
+                        RESULT_FILE: RESULT_FILE,
                         STATE_FILE: STATE_FILE,
                         SESSION_ID: this.sessionId,
                     });
@@ -524,15 +526,15 @@ class CodesysSessionManager extends events_1.EventEmitter {
             this.resetIdleTimeout();
             // Mark the session as busy
             this.sessionState = exports.SessionState.BUSY;
-            // Check if the command pipe exists
-            if (!fs.existsSync(this.commandPipePath)) {
+            // Check if the command file exists
+            if (!fs.existsSync(this.commandFilePath)) {
                 this.sessionState = exports.SessionState.ERROR;
-                throw new Error(`Command pipe not found at ${this.commandPipePath}`);
+                throw new Error(`Command file not found at ${this.commandFilePath}`);
             }
-            // Check if the result pipe exists
-            if (!fs.existsSync(this.resultPipePath)) {
+            // Check if the result file exists
+            if (!fs.existsSync(this.resultFilePath)) {
                 this.sessionState = exports.SessionState.ERROR;
-                throw new Error(`Result pipe not found at ${this.resultPipePath}`);
+                throw new Error(`Result file not found at ${this.resultFilePath}`);
             }
             // Return a promise that will be resolved when script execution completes
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -571,15 +573,21 @@ class CodesysSessionManager extends events_1.EventEmitter {
                     // Create the command to send
                     const command = {
                         id: scriptId,
+                        type: "execute_script",
                         script: scriptContent,
                         timestamp: Date.now()
                     };
-                    // Send the command
-                    const commandString = JSON.stringify(command) + '\n';
-                    fs.writeFileSync(this.commandPipePath, commandString);
-                    console.error(`SESSION_MANAGER: Command sent to pipe`);
-                    // Start reading the result pipe
-                    this.readResultPipe(scriptId);
+                    // Prepare the command data
+                    const commandData = {
+                        status: "pending",
+                        command: command,
+                        timestamp: Date.now()
+                    };
+                    // Send the command by writing to the command file
+                    fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData));
+                    console.error(`SESSION_MANAGER: Command written to file`);
+                    // Start reading the result file
+                    this.readResultFile(scriptId);
                 }
                 catch (error) {
                     console.error(`SESSION_MANAGER: Error executing script: ${error.message}`);
@@ -599,12 +607,12 @@ class CodesysSessionManager extends events_1.EventEmitter {
         });
     }
     /**
-     * Read the result pipe for a specific script execution
+     * Read the result file for a specific script execution
      * @param scriptId The script ID to read results for
      */
-    readResultPipe(scriptId) {
-        console.error(`SESSION_MANAGER: Starting to read result pipe for script ${scriptId}`);
-        // We'll use a polling approach to read from the pipe
+    readResultFile(scriptId) {
+        console.error(`SESSION_MANAGER: Starting to read result file for script ${scriptId}`);
+        // We'll use a polling approach to read from the file
         const pollInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             try {
                 if (!this.pendingScripts.has(scriptId)) {
@@ -612,21 +620,19 @@ class CodesysSessionManager extends events_1.EventEmitter {
                     clearInterval(pollInterval);
                     return;
                 }
-                // Check if the result pipe exists
-                if (!fs.existsSync(this.resultPipePath)) {
-                    console.error(`SESSION_MANAGER: Result pipe not found at ${this.resultPipePath}`);
+                // Check if the result file exists
+                if (!fs.existsSync(this.resultFilePath)) {
+                    console.error(`SESSION_MANAGER: Result file not found at ${this.resultFilePath}`);
                     return;
                 }
-                // Read the result pipe
-                const resultContent = yield (0, promises_1.readFile)(this.resultPipePath, 'utf8');
-                // Process all lines
-                const lines = resultContent.split('\n');
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const result = JSON.parse(line);
-                        // Check if this result is for our script
+                // Read the result file
+                const resultContent = yield (0, promises_1.readFile)(this.resultFilePath, 'utf8');
+                try {
+                    // Parse the result data
+                    const resultData = JSON.parse(resultContent);
+                    // Check if the result is complete and for our script
+                    if (resultData.status === 'complete' && resultData.result) {
+                        const result = resultData.result;
                         if (result.id === scriptId) {
                             console.error(`SESSION_MANAGER: Found result for script ${scriptId}`);
                             // Remove from pending scripts
@@ -647,14 +653,13 @@ class CodesysSessionManager extends events_1.EventEmitter {
                             return;
                         }
                     }
-                    catch (parseError) {
-                        console.error(`SESSION_MANAGER: Error parsing result line: ${parseError}`);
-                        // Continue with the next line
-                    }
+                }
+                catch (parseError) {
+                    console.error(`SESSION_MANAGER: Error parsing result data: ${parseError}`);
                 }
             }
             catch (error) {
-                console.error(`SESSION_MANAGER: Error reading result pipe: ${error}`);
+                console.error(`SESSION_MANAGER: Error reading result file: ${error}`);
             }
         }), 100); // Poll every 100ms
         // Set a timeout to stop polling after the script timeout

package/package.json

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