@codesys/mcp-toolkit 1.2.1 → 1.2.4

package/dist/scripts/start_session.py

@@ -0,0 +1,240 @@
+import sys, os, threading, 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_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")
+
+def setup_session_dir():
+    """Create the session directory and pipes if they don't exist"""
+    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,
+            "start_time": time.time(),
+            "project_open": False,
+            "project_name": "",
+            "project_path": ""
+        }
+        
+        with open(SESSION_STATE_FILE, 'w') as f:
+            json.dump(session_state, f)
+        
+        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():
+    """Update the session state file with current CODESYS state"""
+    try:
+        # Get current state
+        project_open = False
+        project_name = "No project open"
+        project_path = "N/A"
+        
+        primary_project = script_engine.projects.primary
+        if primary_project:
+            project_open = True
+            try:
+                project_path = os.path.normcase(os.path.abspath(primary_project.path))
+                try:
+                    project_name = primary_project.get_name()
+                    if not project_name:
+                        project_name = f"Unnamed (path: {os.path.basename(project_path)})"
+                except:
+                    project_name = f"Unnamed (path: {os.path.basename(project_path)})"
+            except Exception as e_path:
+                project_path = f"N/A (Error: {e_path})"
+                project_name = "Unnamed (Path Error)"
+        
+        # Read current state file
+        with open(SESSION_STATE_FILE, 'r') as f:
+            session_state = json.load(f)
+        
+        # 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()
+        
+        # Write updated state
+        with open(SESSION_STATE_FILE, 'w') as f:
+            json.dump(session_state, f)
+            
+        return True
+    except Exception as e:
+        print(f"Failed to update session state: {e}")
+        return False
+
+def execute_command(command_data):
+    """Execute a command from the command pipe"""
+    try:
+        cmd_type = command_data.get("type", "")
+        script = command_data.get("script", "")
+        cmd_id = command_data.get("id", "unknown")
+        
+        result = {
+            "id": cmd_id,
+            "success": False,
+            "output": "",
+            "error": ""
+        }
+        
+        if cmd_type == "execute_script" and script:
+            # Execute the script in the current CODESYS context
+            try:
+                # Capture output by redirecting stdout/stderr
+                import io
+                from contextlib import redirect_stdout, redirect_stderr
+                
+                stdout_buffer = io.StringIO()
+                stderr_buffer = io.StringIO()
+                
+                with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+                    # Execute the script
+                    exec(script, globals())
+                
+                # Get the captured output
+                stdout_output = stdout_buffer.getvalue()
+                stderr_output = stderr_buffer.getvalue()
+                
+                # Check for success/error markers
+                if SCRIPT_SUCCESS_MARKER in stdout_output or SCRIPT_SUCCESS_MARKER in stderr_output:
+                    result["success"] = True
+                elif SCRIPT_ERROR_MARKER in stdout_output or SCRIPT_ERROR_MARKER in stderr_output:
+                    result["success"] = False
+                else:
+                    # No explicit markers, assume success
+                    result["success"] = True
+                
+                result["output"] = stdout_output
+                if stderr_output:
+                    result["error"] = stderr_output
+            
+            except Exception as e:
+                result["success"] = False
+                result["error"] = f"Error executing script: {str(e)}"
+                result["output"] = f"{SCRIPT_ERROR_MARKER}: {str(e)}"
+        
+        elif cmd_type == "stop":
+            # Stop command received
+            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)
+            
+            # Return the result and signal to stop the loop
+            return result, True
+        
+        else:
+            result["success"] = False
+            result["error"] = f"Unknown command type: {cmd_type}"
+            result["output"] = f"{SCRIPT_ERROR_MARKER}: Unknown command type: {cmd_type}"
+        
+        # Update session state after command execution
+        update_session_state()
+        
+        return result, False
+        
+    except Exception as e:
+        return {
+            "id": command_data.get("id", "unknown"),
+            "success": False,
+            "output": f"{SCRIPT_ERROR_MARKER}: Command execution failed",
+            "error": str(e)
+        }, False
+
+def command_loop():
+    """Main loop to listen for and execute commands"""
+    stop_requested = False
+    
+    print(f"Starting command loop...")
+    print(f"Command pipe: {COMMAND_PIPE}")
+    print(f"Result pipe: {RESULT_PIPE}")
+    
+    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))
+        
+        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)
+    
+    print("Command loop stopped.")
+
+# Main script
+def main():
+    try:
+        # Setup session directory and pipes
+        if not setup_session_dir():
+            sys.exit(1)
+        
+        # Update initial session state
+        update_session_state()
+        
+        # Start command loop
+        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session started")
+        command_loop()
+        
+        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)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/dist/scripts/stop_session.py

@@ -0,0 +1,94 @@
+import sys, os, json, time, tempfile
+
+# Define markers for script results
+SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
+SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
+
+# Session state file and pipes
+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")
+
+def check_session_active():
+    """Check if a session is active by reading the state file"""
+    try:
+        if not os.path.exists(SESSION_STATE_FILE):
+            print(f"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")
+            return False
+            
+        stop_command = {
+            "id": f"stop_{time.time()}",
+            "type": "stop",
+            "script": ""
+        }
+        
+        # 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:
+            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
+
+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")
+        else:
+            print(f"{SCRIPT_ERROR_MARKER}: Failed to stop session")
+            sys.exit(1)
+            
+    except Exception as e:
+        print(f"Error stopping session: {e}")
+        print(f"{SCRIPT_ERROR_MARKER}: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()