@codesys/mcp-toolkit 1.2.0 → 1.2.4

package/dist/scripts/session_status.py

@@ -0,0 +1,168 @@
+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_status():
+    """Check the status of a CODESYS session by reading the state file"""
+    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
+        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
+        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}"
+        }
+
+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')"
+        }
+        
+        # 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))
+        
+        # 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)
+        
+        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)
+        
+        if result_json:
+            try:
+                result = json.loads(result_json)
+                return result.get("success", False)
+            except json.JSONDecodeError:
+                return False
+        else:
+            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)
+
+if __name__ == "__main__":
+    main()

package/dist/scripts/set_pou_code.py

@@ -0,0 +1,104 @@
+import sys, scriptengine as script_engine, os, traceback
+
+# Import ensure_project_open function from the template
+# This will be prepended by the script loader
+def ensure_project_open(target_project_path):
+    # Function implementation will be included from ensure_project_open.py
+    pass
+
+# Import find_object_by_path function from the template
+# This will be prepended by the script loader
+def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
+    # Function implementation will be included from find_object_by_path.py
+    pass
+
+POU_FULL_PATH = "{POU_FULL_PATH}" # Expecting format like "Application/MyPOU" or "Folder/SubFolder/MyPOU"
+DECLARATION_CONTENT = """{DECLARATION_CONTENT}"""
+IMPLEMENTATION_CONTENT = """{IMPLEMENTATION_CONTENT}"""
+
+try:
+    print("DEBUG: set_pou_code script: POU_FULL_PATH='%s', Project='%s'" % (POU_FULL_PATH, PROJECT_FILE_PATH))
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    if not POU_FULL_PATH: raise ValueError("POU full path empty.")
+
+    # Find the target POU/Method/Property object
+    target_object = find_object_by_path_robust(primary_project, POU_FULL_PATH, "target object")
+    if not target_object: raise ValueError("Target object not found using path: %s" % POU_FULL_PATH)
+
+    target_name = getattr(target_object, 'get_name', lambda: POU_FULL_PATH)()
+    print("DEBUG: Found target object: %s" % target_name)
+
+    # --- Set Declaration Part ---
+    declaration_updated = False
+    # Check if the content is actually provided (might be None/empty if only impl is set)
+    has_declaration_content = 'DECLARATION_CONTENT' in locals() or 'DECLARATION_CONTENT' in globals()
+    if has_declaration_content and DECLARATION_CONTENT is not None: # Check not None
+        if hasattr(target_object, 'textual_declaration'):
+            decl_obj = target_object.textual_declaration
+            if decl_obj and hasattr(decl_obj, 'replace'):
+                try:
+                    print("DEBUG: Accessing textual_declaration...")
+                    decl_obj.replace(DECLARATION_CONTENT)
+                    print("DEBUG: Set declaration text using replace().")
+                    declaration_updated = True
+                except Exception as decl_err:
+                    print("ERROR: Failed to set declaration text: %s" % decl_err)
+                    traceback.print_exc() # Print stack trace for detailed error
+            else:
+                 print("WARN: Target '%s' textual_declaration attribute is None or does not have replace(). Skipping declaration update." % target_name)
+        else:
+            print("WARN: Target '%s' does not have textual_declaration attribute. Skipping declaration update." % target_name)
+    else:
+         print("DEBUG: Declaration content not provided or is None. Skipping declaration update.")
+
+
+    # --- Set Implementation Part ---
+    implementation_updated = False
+    has_implementation_content = 'IMPLEMENTATION_CONTENT' in locals() or 'IMPLEMENTATION_CONTENT' in globals()
+    if has_implementation_content and IMPLEMENTATION_CONTENT is not None: # Check not None
+        if hasattr(target_object, 'textual_implementation'):
+            impl_obj = target_object.textual_implementation
+            if impl_obj and hasattr(impl_obj, 'replace'):
+                try:
+                    print("DEBUG: Accessing textual_implementation...")
+                    impl_obj.replace(IMPLEMENTATION_CONTENT)
+                    print("DEBUG: Set implementation text using replace().")
+                    implementation_updated = True
+                except Exception as impl_err:
+                     print("ERROR: Failed to set implementation text: %s" % impl_err)
+                     traceback.print_exc() # Print stack trace for detailed error
+            else:
+                 print("WARN: Target '%s' textual_implementation attribute is None or does not have replace(). Skipping implementation update." % target_name)
+        else:
+            print("WARN: Target '%s' does not have textual_implementation attribute. Skipping implementation update." % target_name)
+    else:
+        print("DEBUG: Implementation content not provided or is None. Skipping implementation update.")
+
+
+    # --- SAVE THE PROJECT TO PERSIST THE CODE CHANGE ---
+    # Only save if something was actually updated to avoid unnecessary saves
+    if declaration_updated or implementation_updated:
+        try:
+            print("DEBUG: Saving Project (after code change)...")
+            primary_project.save() # Save the overall project file
+            print("DEBUG: Project saved successfully after code change.")
+        except Exception as save_err:
+            print("ERROR: Failed to save Project after setting code: %s" % save_err)
+            detailed_error = traceback.format_exc()
+            error_message = "Error saving Project after code change for '%s': %s\\n%s" % (target_name, save_err, detailed_error)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+    else:
+         print("DEBUG: No code parts were updated, skipping project save.")
+    # --- END SAVING ---
+
+    print("Code Set For: %s" % target_name)
+    print("Path: %s" % POU_FULL_PATH)
+    print("SCRIPT_SUCCESS: Declaration and/or implementation set successfully.")
+    sys.exit(0)
+
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error setting code for object '%s' in project '%s': %s\\n%s" % (POU_FULL_PATH, PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message)
+    print("SCRIPT_ERROR: %s" % error_message)
+    sys.exit(1)

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()