@codesys/mcp-toolkit 1.2.4 → 1.4.0

package/dist/scripts/start_session.py

@@ -1,49 +1,88 @@
-import sys, os, threading, json, time, tempfile
+import sys, os, json, time, tempfile, traceback
 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.1  # seconds (faster polling for better responsiveness)
+MAX_INACTIVITY_TIME = 600  # seconds (10 minutes of inactivity before auto-shutdown)
 
 def setup_session_dir():
-    """Create the session directory and pipes if they don't exist"""
+    """Create the session directory and initial files"""
     try:
+        # Clean up any existing session first
+        if os.path.exists(SESSION_DIR):
+            try:
+                # Try to read existing session state
+                if os.path.exists(SESSION_STATE_FILE):
+                    try:
+                        with open(SESSION_STATE_FILE, 'r') as f:
+                            old_state = json.load(f)
+                            print(f"Cleaning up previous session (ID: {old_state.get('session_id', 'unknown')})")
+                    except:
+                        pass
+                
+                # Remove all files in the directory
+                for filename in os.listdir(SESSION_DIR):
+                    filepath = os.path.join(SESSION_DIR, filename)
+                    try:
+                        if os.path.isfile(filepath):
+                            os.unlink(filepath)
+                    except Exception as e:
+                        print(f"Error removing file {filepath}: {e}")
+            except Exception as e:
+                print(f"Error cleaning up previous session: {e}")
+        
         # 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_id = str(time.time()) + "_" + str(os.getpid())
         session_state = {
             "active": True,
+            "session_id": session_id,
             "start_time": time.time(),
+            "last_activity": time.time(),
+            "status": "running",
             "project_open": False,
             "project_name": "",
-            "project_path": ""
+            "project_path": "",
+            "version": "1.0"
         }
         
+        # Write session state
         with open(SESSION_STATE_FILE, 'w') as f:
-            json.dump(session_state, f)
+            json.dump(session_state, f, indent=2)
         
+        # Create empty command file
+        with open(COMMAND_FILE, 'w') as f:
+            json.dump({"status": "ready", "command": None, "timestamp": time.time()}, f, indent=2)
+        
+        # Create empty result file
+        with open(RESULT_FILE, 'w') as f:
+            json.dump({"status": "none", "result": None, "timestamp": time.time()}, f, indent=2)
+        
+        # Create lock file
+        with open(SESSION_LOCK_FILE, 'w') as f:
+            f.write(str(time.time()))
+        
+        print(f"Session directory setup at: {SESSION_DIR}")
+        print(f"Session ID: {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)}")
         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
@@ -67,28 +106,41 @@ def update_session_state():
                 project_name = "Unnamed (Path Error)"
         
         # Read current state file
-        with open(SESSION_STATE_FILE, 'r') as f:
-            session_state = json.load(f)
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
+                session_state = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            # State file doesn't exist or is invalid, create a new one
+            session_id = str(time.time()) + "_" + str(os.getpid())
+            session_state = {
+                "active": True,
+                "session_id": session_id,
+                "start_time": time.time(),
+                "status": status,
+                "version": "1.0"
+            }
         
         # Update state
         session_state["project_open"] = project_open
         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:
-            json.dump(session_state, f)
+            json.dump(session_state, f, indent=2)
             
         return True
     except Exception as e:
         print(f"Failed to update session state: {e}")
+        traceback.print_exc()
         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")
         
@@ -102,6 +154,10 @@ def execute_command(command_data):
         if cmd_type == "execute_script" and script:
             # Execute the script in the current CODESYS context
             try:
+                # Create a temporary globals dictionary with the current globals
+                # This allows us to isolate the script execution somewhat
+                local_globals = globals().copy()
+                
                 # Capture output by redirecting stdout/stderr
                 import io
                 from contextlib import redirect_stdout, redirect_stderr
@@ -111,7 +167,7 @@ def execute_command(command_data):
                 
                 with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
                     # Execute the script
-                    exec(script, globals())
+                    exec(script, local_globals)
                 
                 # Get the captured output
                 stdout_output = stdout_buffer.getvalue()
@@ -131,8 +187,9 @@ def execute_command(command_data):
                     result["error"] = stderr_output
             
             except Exception as e:
+                traceback.print_exc()
                 result["success"] = False
-                result["error"] = f"Error executing script: {str(e)}"
+                result["error"] = f"Error executing script: {str(e)}\n{traceback.format_exc()}"
                 result["output"] = f"{SCRIPT_ERROR_MARKER}: {str(e)}"
         
         elif cmd_type == "stop":
@@ -140,19 +197,17 @@ 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
         
+        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"
+        
         else:
             result["success"] = False
             result["error"] = f"Unknown command type: {cmd_type}"
@@ -164,61 +219,161 @@ def execute_command(command_data):
         return result, False
         
     except Exception as e:
+        traceback.print_exc()
         return {
             "id": command_data.get("id", "unknown"),
             "success": False,
             "output": f"{SCRIPT_ERROR_MARKER}: Command execution failed",
-            "error": str(e)
+            "error": f"{str(e)}\n{traceback.format_exc()}"
         }, False
 
+def check_command():
+    """Check if there is a new command to execute"""
+    try:
+        # If command file doesn't exist, return immediately
+        if not os.path.exists(COMMAND_FILE):
+            return False
+            
+        # Read the command file
+        try:
+            with open(COMMAND_FILE, 'r') as f:
+                command_data = json.load(f)
+        except json.JSONDecodeError:
+            # If command file is corrupted, reset it
+            command_data = {"status": "ready", "command": None, "timestamp": time.time()}
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump(command_data, f, indent=2)
+            return False
+        
+        # Check if there's a new command
+        if command_data.get("status") == "pending" and command_data.get("command"):
+            # 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")
+            
+            # Update last activity time
+            update_last_activity()
+            
+            return stop_requested
+        
+        return False
+    except Exception as e:
+        print(f"Error checking command: {e}")
+        traceback.print_exc()
+        return False
+
+def update_last_activity():
+    """Update the last activity timestamp in the session state"""
+    try:
+        if os.path.exists(SESSION_STATE_FILE):
+            with open(SESSION_STATE_FILE, 'r') as f:
+                state = json.load(f)
+            
+            state["last_activity"] = time.time()
+            
+            with open(SESSION_STATE_FILE, 'w') as f:
+                json.dump(state, f, indent=2)
+    except Exception as e:
+        print(f"Error updating last activity: {e}")
+
+def check_inactivity_timeout():
+    """Check if session has been inactive for too long"""
+    try:
+        if os.path.exists(SESSION_STATE_FILE):
+            with open(SESSION_STATE_FILE, 'r') as f:
+                state = json.load(f)
+            
+            last_activity = state.get("last_activity", state.get("start_time", time.time()))
+            current_time = time.time()
+            
+            if (current_time - last_activity) > MAX_INACTIVITY_TIME:
+                print(f"Session inactive for {current_time - last_activity:.1f} seconds, shutting down")
+                return True
+        
+        return False
+    except Exception as e:
+        print(f"Error checking inactivity timeout: {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
+    last_state_update = time.time()
     
     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()
+            # 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()
+            
+            # Check for inactivity timeout
+            if check_inactivity_timeout():
+                print("Session timeout due to inactivity")
+                update_session_state("timeout")
+                stop_requested = True
                 
-                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))
+            # Periodically update session state (every 30 seconds)
+            current_time = time.time()
+            if (current_time - last_state_update) > 30:
+                update_session_state()
+                last_state_update = current_time
+            
+            # Sleep for a bit
+            time.sleep(POLL_INTERVAL)
         
         except Exception as e:
             print(f"Error in command loop: {e}")
-            # Short delay to prevent CPU spinning in case of repeated errors
-            time.sleep(0.5)
+            traceback.print_exc()
+            # 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,11 +384,15 @@ 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:
         print(f"Error in session: {e}")
         print(f"{SCRIPT_ERROR_MARKER}: Session failed - {str(e)}")
+        traceback.print_exc()
         sys.exit(1)
 
 if __name__ == "__main__":

package/dist/scripts/stop_session.py

@@ -1,94 +1,150 @@
-import sys, os, json, time, tempfile
+import sys, os, json, time, traceback
+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
-            
-        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
 
-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")
+        # Read session state
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
+                session_state = json.load(f)
+        except json.JSONDecodeError:
+            print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
+            return False
+
+        # 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")
+            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
-            
+
+        # Try to read the lock file to check if session is still alive
+        lock_time = 0
+        try:
+            if os.path.exists(SESSION_LOCK_FILE):
+                with open(SESSION_LOCK_FILE, 'r') as f:
+                    lock_time = float(f.read().strip())
+                    
+                current_time = time.time()
+                if (current_time - lock_time) > 30:
+                    print(f"WARNING: Session lock file is stale ({current_time - lock_time:.1f} seconds old). Session may have crashed.")
+        except Exception as e:
+            print(f"Warning: Error reading lock file: {e}")
+
+        # Create stop command
         stop_command = {
-            "id": f"stop_{time.time()}",
+            "id": f"stop_{int(time.time())}",
             "type": "stop",
-            "script": ""
+            "timestamp": time.time()
+        }
+
+        # Write command to file with pretty-printing
+        command_data = {
+            "status": "pending",
+            "command": stop_command,
+            "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:
+
+        with open(COMMAND_FILE, 'w') as f:
+            json.dump(command_data, f, indent=2)
+
+        print(f"Stop command sent to session")
+
+        # Wait for result (with timeout)
+        timeout = 15  # seconds (increased timeout for more reliability)
+        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)
-            
-            # 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")
+        # Update session state to indicate it's stopped regardless of result
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
+                session_state = json.load(f)
+                
+            session_state['active'] = False
+            session_state['status'] = "stopped"
+            session_state['end_time'] = time.time()
+
+            with open(SESSION_STATE_FILE, 'w') as f:
+                json.dump(session_state, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Failed to update session state file: {e}")
+
+        if result_received:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session stopped successfully")
+            return True
         else:
-            print(f"{SCRIPT_ERROR_MARKER}: Failed to stop session")
-            sys.exit(1)
-            
+            # 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.")
+            try:
+                # Try to remove all session files to ensure a clean state for next session
+                for filename in os.listdir(SESSION_DIR):
+                    filepath = os.path.join(SESSION_DIR, filename)
+                    try:
+                        if os.path.isfile(filepath):
+                            os.unlink(filepath)
+                    except Exception as e:
+                        print(f"Error removing file {filepath}: {e}")
+                
+                print(f"{SCRIPT_SUCCESS_MARKER}: Session files cleaned up forcefully")
+                return True
+            except Exception as e:
+                print(f"{SCRIPT_ERROR_MARKER}: Failed to force cleanup - {str(e)}")
+                return False
+
     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)}")
+        traceback.print_exc()
+        return False
 
+# Main script
 if __name__ == "__main__":
-    main()
+    if stop_session():
+        sys.exit(0)
+    else:
+        sys.exit(1)