@codesys/mcp-toolkit 1.1.4 → 1.1.5

package/codesys_scripts/listener_script.py

@@ -0,0 +1,1539 @@
+import socket
+import sys
+import threading
+import json
+import time
+import traceback # Import traceback for detailed error logging
+import os # Import os for path manipulation
+import shutil # Import shutil for file operations (used in create_project)
+
+# Import CODESYS Scripting libraries
+# These imports are conceptual as the exact names might vary.
+# You might need to adjust these based on your CODESYS installation and scripting environment setup.
+# Ensure the CODESYS scripting environment makes these available.
+try:
+    # Assuming the scripting environment makes these available globally or via a specific import
+    # If not, you might need a different approach to access CODESYS objects
+    import scriptengine # Use import scriptengine as script_engine based on your scripts
+    from Script import * # Assuming Script object is available
+    from ScriptOnline import * # Assuming ScriptOnline object is available
+    # Import specific enums used in your scripts
+    from scriptengine import PouType # Used in create_pou
+    # from scriptengine import ImplementationLanguage # If needed for language mapping
+    # from scriptengine import VersionUpdateFlags # Used in open_project
+    print("CODESYS Scripting libraries imported.")
+except ImportError:
+    print("Warning: CODESYS Scripting libraries not found. Running in simulation mode.")
+    # Define dummy classes/objects for testing outside CODESYS if needed
+    # (Keep the dummy classes from the previous version for simulation)
+    class DummyOnlineApplication:
+        def login(self, change_option, delete_foreign_apps):
+            print("Dummy login called.")
+            time.sleep(0.1)
+            return True
+        def logout(self):
+            print("Dummy logout called.")
+            time.sleep(0.1)
+        def start(self):
+            print("Dummy start called.")
+            time.sleep(0.1)
+        def stop(self):
+            print("Dummy stop called.")
+            time.sleep(0.1)
+        def read_value(self, expression):
+            print(f"Dummy read_value called for {expression}")
+            time.sleep(0.05)
+            return f"DummyValue_{expression}"
+        def write_prepared_values(self):
+             print("Dummy write_prepared_values called.")
+             time.sleep(0.1)
+        def set_prepared_value(self, expression, value):
+             print(f"Dummy set_prepared_value called for {expression} = {value}")
+             time.sleep(0.05)
+        def Dispose(self):
+             print("Dummy Dispose called.")
+
+    class DummyOnlineDevice:
+         def Dispose(self):
+              print("Dummy Dispose called.")
+
+    # Dummy Script object for project operations
+    class DummyScriptEngine:
+        def __init__(self):
+            self.projects = DummyProjects()
+
+    class DummyProjects:
+        def __init__(self):
+            self.primary = None # Simulate no project open initially
+
+        def open(self, path, update_flags=None):
+            print(f"Dummy scriptengine.projects.open called for {path}")
+            time.sleep(0.5)
+            # Simulate returning a project object or None
+            if os.path.exists(path):
+                 print("Dummy project opened successfully.")
+                 self.primary = DummyProject(path) # Set as primary
+                 return self.primary
+            else:
+                 print("Dummy project not found.")
+                 self.primary = None
+                 return None
+
+    class DummyProject:
+         def __init__(self, path):
+             self.path = path
+             self.active_application = DummyApplication() # Simulate an active application
+
+         def save(self): # Use lowercase save based on save_project.py
+             print(f"Dummy Project.save() called for {self.path}")
+             time.sleep(0.3)
+             print("Dummy project saved.")
+             return True # Simulate success
+
+         def SaveAs(self, path): # Used in create_project simulation
+             print(f"Dummy Project.SaveAs() called for {self.path} to {path}")
+             self.path = path # Update path
+             time.sleep(0.3)
+             print("Dummy project saved as.")
+             return True
+
+         def Close(self):
+             print(f"Dummy Project.Close() called for {self.path}")
+             time.sleep(0.2)
+             # In dummy, we don't unset primary here, real CODESYS might.
+
+         def FindObject(self, path): # Used in find_object_by_path_robust simulation
+             print(f"Dummy Project.FindObject() called for {path}")
+             time.sleep(0.1)
+             # Simulate finding a POU
+             if "PLC_PRG" in path:
+                 return DummyPou(path)
+             # Simulate finding Application
+             if path.lower() == "application":
+                 return self.active_application
+             return None # Simulate not found
+
+         def get_children(self, recursive=False): # Use lowercase get_children based on scripts
+             print(f"Dummy Project.get_children(recursive={recursive}) called.")
+             # Simulate returning some child objects for structure
+             # This dummy structure needs to match what find_object_by_path_robust expects
+             children = [
+                 DummyObject("Device"),
+                 self.active_application # Include the application
+             ]
+             if recursive:
+                 all_children = []
+                 for child in children:
+                     all_children.append(child)
+                     if hasattr(child, 'get_children'):
+                         all_children.extend(child.get_children(recursive=True))
+                 return all_children
+             return children
+
+         def get_name(self): # Use lowercase get_name based on scripts
+             print(f"Dummy Project.get_name() called for {self.path}")
+             return os.path.basename(self.path)
+
+
+    class DummyObject: # Base class for project items
+         def __init__(self, name, children=None):
+             self._name = name
+             self._children = children if children is not None else []
+
+         def get_name(self): # Use lowercase get_name
+             return self._name
+
+         def get_children(self, recursive=False): # Use lowercase get_children
+             print(f"Dummy Object.get_children(recursive={recursive}) called for {self._name}")
+             if recursive:
+                 all_children = []
+                 for child in self._children:
+                     all_children.append(child)
+                     if hasattr(child, 'get_children'):
+                         all_children.extend(child.get_children(recursive=True))
+                 return all_children
+             return self._children
+
+         def get_path(self): # Helper for dummy path simulation
+             # Simple path simulation - needs refinement for nested objects
+             return self._name
+
+
+    class DummyPou(DummyObject): # Simulate POU, Method, Property
+         def __init__(self, path):
+             super().__init__(path.split('.')[-1]) # Name is the last part of the path
+             self.path = path
+             self.declaration = f"VAR\n\t// Dummy declaration for {path}\nEND_VAR"
+             self.implementation = f"// Dummy implementation for {path}\n"
+             self.textual_declaration = DummyTextualObject(self.declaration) # Simulate textual objects
+             self.textual_implementation = DummyTextualObject(self.implementation) # Simulate textual objects
+
+         def GetDeclaration(self): # Use uppercase GetDeclaration based on set_pou_code simulation
+             print(f"Dummy Pou.GetDeclaration() called for {self.path}")
+             return self.declaration
+
+         def GetImplementation(self): # Use uppercase GetImplementation based on set_pou_code simulation
+             print(f"Dummy Pou.GetImplementation() called for {self.path}")
+             return self.implementation
+
+         # Simulate methods used in set_pou_code
+         # Note: The real API uses .textual_declaration/.textual_implementation objects with a .replace() method
+         # The dummy TextualObject handles the replace logic.
+
+         def create_method(self, name, return_type, language): # Use lowercase create_method
+             print(f"Dummy Pou.create_method() called for {self.path}. Method: {name}, ReturnType: {return_type}, Lang: {language}")
+             # Simulate creating a method object
+             method_path = f"{self.path}.{name}"
+             new_method = DummyPou(method_path) # Methods are also like POUs in structure
+             self._children.append(new_method)
+             return new_method # Simulate returning the new method object
+
+         def create_property(self, name, return_type, language): # Use lowercase create_property
+             print(f"Dummy Pou.create_property() called for {self.path}. Property: {name}, Type: {return_type}, Lang: {language}")
+             # Simulate creating a property object
+             property_path = f"{self.path}.{name}"
+             new_property = DummyPou(property_path) # Properties might be simpler objects, but use Pou for now
+             self._children.append(new_property)
+             return new_property # Simulate returning the new property object
+
+
+    class DummyTextualObject: # Simulate objects like textual_declaration, textual_implementation
+         def __init__(self, content):
+             self._content = content
+
+         def replace(self, new_content):
+             print(f"Dummy TextualObject.replace() called. Old content: '{self._content[:20]}...', New content: '{new_content[:20]}...'")
+             self._content = new_content
+             return True # Simulate success
+
+
+    class DummyApplication(DummyObject): # Simulate Application object
+         def __init__(self):
+             super().__init__("Application")
+             self.is_application = True # Attribute used in compile_project
+             self._children = [DummyPou("Application.PLC_PRG")] # Default PLC_PRG
+
+         def FindObject(self, path): # Used in find_object_by_path_robust simulation
+             print(f"Dummy Application.FindObject() called for {path}")
+             # Simple find logic within application children
+             for child in self._children:
+                 if child.get_path() == path:
+                     return child
+             return None
+
+         def create_pou(self, name, type, language): # Use lowercase create_pou
+             print(f"Dummy Application.create_pou() called. Name: {name}, Type: {type}, Lang: {language}")
+             # Simulate creating a new POU under Application
+             new_pou_path = f"Application.{name}"
+             new_pou = DummyPou(new_pou_path)
+             self._children.append(new_pou)
+             return new_pou # Simulate returning the new POU object
+
+         def build(self): # Use lowercase build based on compile_project
+             print("Dummy Application.build() called.")
+             time.sleep(1) # Simulate compile time
+             print("Dummy build finished.")
+             return True # Simulate success
+
+
+    class DummyProjectManager: # Simulate ProjectManager object
+         def GetActiveProject(self): # Use uppercase GetActiveProject based on listener script
+             print("Dummy ProjectManager.GetActiveProject() called.")
+             # Simulate returning the currently active project from DummyProjects
+             return scriptengine.projects.primary
+
+
+    scriptengine = DummyScriptEngine() # Assign the dummy scriptengine object
+    ScriptOnline = DummyScriptOnline() # Assign the dummy ScriptOnline object
+    # Define dummy enums if needed
+    class DummyOnlineChangeOption:
+        Try = 1
+    OnlineChangeOption = DummyOnlineChangeOption()
+    class DummyPouType: # Simulate PouType enum
+        Program = "Program"
+        FunctionBlock = "FunctionBlock"
+        Function = "Function"
+    PouType = DummyPouType()
+    # Dummy VersionUpdateFlags if needed
+    class DummyVersionUpdateFlags:
+        NoUpdates = 1
+        SilentMode = 2
+    VersionUpdateFlags = DummyVersionUpdateFlags()
+
+    # Dummy exception for ValuesFailedException
+    class DummyValuesFailedException(Exception):
+        def __init__(self, failed_expressions, message="Values failed"):
+            super().__init__(message)
+            self.failed_expressions = failed_expressions
+
+    ValuesFailedException = DummyValuesFailedException
+
+
+HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
+PORT = 65432        # Port to listen on (non-privileged ports are > 1023)
+
+# Global variable to hold the active online application/device
+# In a real scenario, you might manage multiple connections or sessions
+online_app = None
+online_device = None
+active_project = None # Global variable to hold the active project object
+
+# --- Helper to get active project ---
+# Adapted from ensure_project_open.py
+MAX_RETRIES = 3
+RETRY_DELAY = 0.5 # seconds (reduced delay for listener context)
+
+def ensure_project_is_active(target_project_path):
+    """Ensures the specified project is the active project in CODESYS."""
+    global active_project
+    print("DEBUG: Ensuring project is active: %s" % target_project_path)
+    normalized_target_path = os.path.normcase(os.path.abspath(target_project_path))
+
+    for attempt in range(MAX_RETRIES):
+        print("DEBUG: Ensure project active attempt %d/%d for %s" % (attempt + 1, MAX_RETRIES, normalized_target_path))
+        current_primary_project = None
+        try:
+            current_primary_project = scriptengine.projects.primary
+        except Exception as primary_err:
+             print("WARN: Error getting primary project: %s. Assuming none." % primary_err)
+             current_primary_project = None
+
+        current_project_path = ""
+        project_ok = False
+
+        if current_primary_project:
+            try:
+                current_project_path = os.path.normcase(os.path.abspath(current_primary_project.path))
+                print("DEBUG: Current primary project path: %s" % current_project_path)
+                if current_project_path == normalized_target_path:
+                    print("DEBUG: Target project path matches primary. Checking access...")
+                    try:
+                         # Try a relatively safe operation to confirm object usability
+                         _ = len(current_primary_project.get_children(False))
+                         print("DEBUG: Target project '%s' is primary and accessible." % target_project_path)
+                         active_project = current_primary_project # Set global active project
+                         project_ok = True
+                         return active_project # SUCCESS CASE 1: Already open and accessible
+                    except Exception as access_err:
+                         print("WARN: Primary project access check failed for '%s': %s. Will attempt reopen." % (current_project_path, access_err))
+                         active_project = None # Force reopen by falling through
+                         current_primary_project = None # Also clear the reference
+                else:
+                     print("DEBUG: Primary project is '%s', not the target '%s'. Attempting to open target." % (current_project_path, normalized_target_path))
+                     # Don't explicitly close the wrong project here, just attempt to open the target
+                     active_project = None
+                     current_primary_project = None
+
+            except Exception as path_err:
+                 print("WARN: Could not get path of current primary project: %s. Assuming not the target." % path_err)
+                 active_project = None
+                 current_primary_project = None
+
+        # If target project not confirmed as primary and accessible, attempt to open/reopen
+        if not project_ok:
+            print("DEBUG: Attempting to open/reopen target project: %s" % target_project_path)
+            try:
+                # Use VersionUpdateFlags from scriptengine
+                update_mode = scriptengine.VersionUpdateFlags.NoUpdates | scriptengine.VersionUpdateFlags.SilentMode
+                opened_project = scriptengine.projects.open(target_project_path, update_flags=update_mode)
+
+                if not opened_project:
+                    print("ERROR: projects.open returned None for %s on attempt %d" % (target_project_path, attempt + 1))
+                    active_project = None
+                else:
+                    print("DEBUG: projects.open call returned an object for: %s" % target_project_path)
+                    # Give CODESYS time to stabilize
+                    time.sleep(RETRY_DELAY)
+                    # Re-verify: Is the project now primary and accessible?
+                    recheck_primary = None
+                    try: recheck_primary = scriptengine.projects.primary
+                    except Exception as recheck_primary_err: print("WARN: Error getting primary project after reopen: %s" % recheck_primary_err)
+
+                    if recheck_primary:
+                         recheck_path = ""
+                         try:
+                             recheck_path = os.path.normcase(os.path.abspath(recheck_primary.path))
+                         except Exception as recheck_path_err:
+                             print("WARN: Failed to get path after reopen: %s" % recheck_path_err)
+
+                         if recheck_path == normalized_target_path:
+                              print("DEBUG: Target project confirmed as primary after reopening.")
+                              try:
+                                  _ = len(recheck_primary.get_children(False))
+                                  print("DEBUG: Reopened project basic access confirmed.")
+                                  active_project = recheck_primary # Set global active project
+                                  return active_project # SUCCESS CASE 2: Successfully opened/reopened
+                              except Exception as access_err_reopen:
+                                   print("WARN: Reopened project (%s) basic access check failed: %s." % (normalized_target_path, access_err_reopen))
+                                   active_project = None
+                         else:
+                              print("WARN: Different project is primary after reopening! Expected '%s', got '%s'." % (normalized_target_path, recheck_path))
+                              active_project = None
+                    else:
+                           print("WARN: No primary project found after reopening attempt %d!" % (attempt+1))
+                           active_project = None
+
+            except Exception as open_err:
+                 print("ERROR: Exception during projects.open call on attempt %d: %s" % (attempt + 1, open_err))
+                 traceback.print_exc()
+                 active_project = None
+
+        # If we didn't return successfully in this attempt, wait before retrying
+        if attempt < MAX_RETRIES - 1:
+            print("DEBUG: Ensure project active attempt %d did not succeed. Waiting %f seconds..." % (attempt + 1, RETRY_DELAY))
+            time.sleep(RETRY_DELAY)
+        else: # Last attempt failed
+             print("ERROR: Failed all ensure_project_is_active attempts for %s." % normalized_target_path)
+
+
+    # If all retries fail after the loop
+    raise RuntimeError("Failed to ensure project '%s' is open and accessible after %d attempts." % (target_project_path, MAX_RETRIES))
+
+# --- End of ensure_project_is_active function ---
+
+
+# --- Helper to find object by path ---
+# Adapted from find_object_by_path.py
+def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
+    """Finds an object within the project hierarchy starting from start_node."""
+    print("DEBUG: Finding %s by path: '%s'" % (target_type_name, full_path))
+    normalized_path = full_path.replace('\\\\', '/').strip('/')
+    path_parts = normalized_path.split('/')
+    if not path_parts or not normalized_path: # Handle empty path after strip
+        print("ERROR: Path is empty after normalization.")
+        return None
+
+    # Determine the actual starting node (project or application)
+    project = None
+    app = None
+
+    # Try to get the project reference from the start_node if it's not the project itself
+    if hasattr(start_node, 'project'):
+         try: project = start_node.project
+         except Exception as proj_ref_err:
+             print("WARN: Could not get project reference from start_node: %s" % proj_ref_err)
+
+    # If start_node *is* the project, use it directly
+    if project is None and hasattr(start_node, 'active_application'): # Check for a project-like object
+         project = start_node
+
+    if not project:
+         print("ERROR: Could not determine the project from the start_node.")
+         return None
+
+    # Try to get the active application robustly
+    if hasattr(project, 'active_application'):
+        try: app = project.active_application
+        except Exception: pass # Ignore errors getting active app
+        if not app:
+            try:
+                 # Search recursively for an application if active_application fails
+                 if hasattr(project, 'find'): # Check if project has find method
+                     apps = project.find("Application", True) # Assuming find method exists on project
+                     if apps: app = apps[0] # Take the first one found
+                 else:
+                     print("WARN: Project object does not have a 'find' method.")
+            except Exception: pass
+
+
+    # Decide where to start the traversal based on the first path part
+    current_obj = start_node # Default to the node passed in
+    remaining_path_parts = list(path_parts) # Create a mutable copy
+
+    if app: # Only consider starting from application if we found one
+        app_name_lower = ""
+        try: app_name_lower = (getattr(app, 'get_name', lambda: "application")() or "application").lower()
+        except Exception: app_name_lower = "application" # Fallback
+
+        # Check if first part matches EITHER the actual app name OR the generic "Application" string
+        if remaining_path_parts[0].lower() == app_name_lower or remaining_path_parts[0].lower() == "application":
+             print("DEBUG: Path starts with Application name or the string 'Application'. Beginning search there.")
+             current_obj = app
+             remaining_path_parts = remaining_path_parts[1:] # Consume the app name part
+             # If path was *only* the application name
+             if not remaining_path_parts:
+                 print("DEBUG: Target path is the Application object itself.")
+                 return current_obj
+        else:
+            print("DEBUG: Path does not start with Application name or string. Starting search from project root.")
+            current_obj = project # Start search from the project root
+    else:
+         print("DEBUG: No application found or path doesn't start with app name. Starting search from originally provided node.")
+         # If start_node was the project, and no app, we still start from project.
+         if hasattr(start_node, 'active_application'):
+              current_obj = start_node
+
+
+    # Traverse the remaining path parts
+    parent_path_str = getattr(current_obj, 'get_name', lambda: str(current_obj))() # Safer name getting
+
+    for i, part_name in enumerate(remaining_path_parts):
+        is_last_part = (i == len(remaining_path_parts) - 1)
+        print("DEBUG: Searching for part [%d/%d]: '%s' under '%s'" % (i+1, len(remaining_path_parts), part_name, parent_path_str))
+        found_in_parent = None
+        try:
+            # Prioritize non-recursive find for direct children
+            if hasattr(current_obj, 'get_children'):
+                children_of_current = current_obj.get_children(False)
+                print("DEBUG: Found %d direct children under '%s'." % (len(children_of_current), parent_path_str))
+                for child in children_of_current:
+                     child_name = getattr(child, 'get_name', lambda: None)() # Safer name getting
+                     # print("DEBUG: Checking child: '%s'" % child_name) # Verbose
+                     if child_name == part_name:
+                         found_in_parent = child
+                         print("DEBUG: Found direct child matching '%s'." % part_name)
+                         break # Found direct child, stop searching children
+
+            # If not found directly, AND it's the last part, try recursive find from current parent
+            # Note: Recursive find might be slow on large projects. Direct traversal is preferred.
+            # The original script tried recursive find only for the last part.
+            if not found_in_parent and is_last_part and hasattr(current_obj, 'find'):
+                 print("DEBUG: Direct find failed for last part '%s'. Trying recursive find under '%s'." % (part_name, parent_path_str))
+                 found_recursive_list = current_obj.find(part_name, True) # Assuming find method exists
+                 if found_recursive_list:
+                     # Maybe add a check here if multiple are found?
+                     found_in_parent = found_recursive_list[0] # Take the first match
+                     print("DEBUG: Found last part '%s' recursively." % part_name)
+                 else:
+                     print("DEBUG: Recursive find also failed for last part '%s'." % part_name)
+            elif not found_in_parent and is_last_part and not hasattr(current_obj, 'find'):
+                 print("DEBUG: Direct find failed for last part '%s'. Parent object '%s' does not have a 'find' method." % (part_name, parent_path_str))
+
+
+            # Update current object if found
+            if found_in_parent:
+                current_obj = found_in_parent
+                parent_path_str = getattr(current_obj, 'get_name', lambda: part_name)() # Safer name getting
+                print("DEBUG: Stepped into '%s'." % parent_path_str)
+            else:
+                # If not found at any point, the path is invalid from this parent
+                print("ERROR: Path part '%s' not found under '%s'." % (part_name, parent_path_str))
+                return None # Path broken
+
+        except Exception as find_err:
+            print("ERROR: Exception while searching for '%s' under '%s': %s" % (part_name, parent_path_str, find_err))
+            traceback.print_exc()
+            return None # Error during search
+
+    # Final verification (optional but recommended): Check if the found object's name matches the last part
+    # This check might be redundant if the traversal logic is perfect, but adds robustness.
+    final_expected_name = normalized_path.split('/')[-1]
+    found_final_name = getattr(current_obj, 'get_name', lambda: None)() # Safer name getting
+
+    if found_final_name == final_expected_name:
+        print("DEBUG: Final %s found and name verified for path '%s': %s" % (target_type_name, full_path, found_final_name))
+        return current_obj
+    else:
+        print("ERROR: Traversal ended on object '%s' but expected final name was '%s' for path '%s'." % (found_final_name, final_expected_name, full_path))
+        return None # Name mismatch implies target not found as expected
+
+# --- End of find object function ---
+
+
+HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
+PORT = 65432        # Port to listen on (non-privileged ports are > 1023)
+
+# Global variable to hold the active online application/device
+# In a real scenario, you might manage multiple connections or sessions
+online_app = None
+online_device = None
+active_project = None # Global variable to hold the active project object
+
+
+def open_project_command(args):
+    """Handles the 'open_project' command."""
+    global active_project
+    project_path = args.get("file_path") # Use file_path as defined in server.ts
+    if not project_path:
+        return {"status": "error", "message": "Missing 'file_path' argument for open_project"}
+    try:
+        print(f"Attempting to open project: {project_path}")
+        # Use the actual CODESYS Scripting API to open the project
+        # Based on ensure_project_open.py
+        # Use VersionUpdateFlags from scriptengine
+        update_mode = scriptengine.VersionUpdateFlags.NoUpdates | scriptengine.VersionUpdateFlags.SilentMode
+        project = scriptengine.projects.open(project_path, update_flags=update_mode)
+
+        if project:
+            active_project = project # Set the global active project
+            print(f"Project opened successfully: {project_path}")
+            return {"status": "success", "message": f"Project opened: {project_path}"}
+        else:
+            print(f"Failed to open project: {project_path}. projects.open returned None.")
+            active_project = None # Ensure no active project if opening fails
+            return {"status": "error", "message": f"Failed to open project: {project_path}"}
+    except Exception as e:
+        print(f"Error opening project: {e}")
+        traceback.print_exc() # Print traceback for detailed error
+        active_project = None
+        return {"status": "error", "message": f"Error opening project: {e}"}
+
+def create_project_command(args):
+    """Handles the 'create_project' command."""
+    global active_project
+    file_path = args.get("file_path")
+    template_path = args.get("template_path")
+    if not file_path or not template_path:
+        return {"status": "error", "message": "Missing arguments for create_project"}
+    try:
+        print(f"Attempting to create project from template: {template_path} at {file_path}")
+
+        # Based on create_project.py, this involves copying the template file
+        target_dir = os.path.dirname(file_path)
+        if not os.path.exists(target_dir):
+            print(f"DEBUG: Creating target directory: {target_dir}")
+            os.makedirs(target_dir)
+
+        if os.path.exists(file_path):
+            print(f"WARN: Target project file already exists, overwriting: {file_path}")
+
+        print(f"DEBUG: Copying '{template_path}' to '{file_path}'...")
+        shutil.copy2(template_path, file_path) # copy2 preserves metadata
+        print("DEBUG: File copy complete.")
+
+        # Then open the newly copied project file
+        print(f"DEBUG: Opening the copied project: {file_path}")
+        # Use VersionUpdateFlags from scriptengine
+        update_mode = scriptengine.VersionUpdateFlags.NoUpdates | scriptengine.VersionUpdateFlags.SilentMode
+        project = scriptengine.projects.open(file_path, update_flags=update_mode)
+
+        if project:
+            active_project = project # Set the global active project
+            print(f"Project created and opened successfully: {file_path}")
+            # Optional: Save the project explicitly after opening the copy, as seen in create_project.py
+            try:
+                print("DEBUG: Explicitly saving project after opening copy...")
+                active_project.save() # Use lowercase save
+                print("DEBUG: Project save after opening copy succeeded.")
+            except Exception as save_err:
+                 print(f"WARN: Explicit save after opening copy failed: {save_err}")
+
+            return {"status": "success", "message": f"Project created and opened: {file_path}"}
+        else:
+            print(f"Failed to open the newly created project: {file_path}. projects.open returned None.")
+            active_project = None
+            return {"status": "error", "message": f"Project created at {file_path}, but failed to open it."}
+    except Exception as e:
+        print(f"Error creating project: {e}")
+        traceback.print_exc()
+        active_project = None
+        return {"status": "error", "message": f"Error creating project: {e}"}
+
+
+def save_project_command(args):
+    """Handles the 'save_project' command."""
+    global active_project
+    project_file_path = args.get("project_file_path")
+    if not project_file_path:
+        return {"status": "error", "message": "Missing 'project_file_path' argument for save_project"}
+
+    # Ensure the correct project is active before saving
+    project = ensure_project_is_active(project_file_path)
+    if not project:
+        return {"status": "error", "message": f"Could not ensure project '{project_file_path}' is active to save."}
+
+    try:
+        print(f"Attempting to save active project: {project.path}")
+        # Use the actual CODESYS Scripting API to save the project
+        # Based on save_project.py
+        project.save() # Use lowercase save
+        print("Project saved successfully.")
+        return {"status": "success", "message": f"Project saved: {project.path}"}
+    except Exception as e:
+        print(f"Error saving project: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error saving project: {e}"}
+
+def create_pou_command(args):
+    """Handles the 'create_pou' command."""
+    global active_project
+    project_file_path = args.get("project_file_path")
+    name = args.get("name")
+    pou_type_str = args.get("type") # Use pou_type_str to avoid conflict with PouType enum
+    language = args.get("language") # Note: create_pou.py passes None for language
+    parent_path = args.get("parent_path")
+
+    if not all([project_file_path, name, pou_type_str, language, parent_path is not None]):
+         return {"status": "error", "message": "Missing arguments for create_pou"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_file_path)
+    if not project:
+        return {"status": "error", "message": f"Could not ensure project '{project_file_path}' is active to create POU in."}
+
+    try:
+        print(f"Attempting to create POU '{name}' (Type: {pou_type_str}, Lang: {language}) under '{parent_path}' in project: {project.path}")
+
+        # Resolve POU Type Enum based on create_pou.py
+        pou_type_map = {
+            "Program": PouType.Program,
+            "FunctionBlock": PouType.FunctionBlock,
+            "Function": PouType.Function
+        }
+        pou_type_enum = pou_type_map.get(pou_type_str)
+        if not pou_type_enum:
+             return {"status": "error", "message": f"Invalid POU type string: {pou_type_str}. Use Program, FunctionBlock, or Function."}
+
+        # Find parent object using the robust function
+        parent_object = find_object_by_path_robust(project, parent_path, "parent container")
+        if not parent_object:
+             return {"status": "error", "message": f"Parent object not found for path: {parent_path}"}
+
+        # Check if parent object supports creating POUs (based on create_pou.py)
+        if not hasattr(parent_object, 'create_pou'):
+            return {"status": "error", "message": f"Parent object '{getattr(parent_object, 'get_name', lambda: str(parent_object))()}' of type {type(parent_object).__name__} does not support create_pou."}
+
+        # Set language GUID to None (let CODESYS default based on parent/settings) based on create_pou.py
+        lang_guid = None
+        print("DEBUG: Setting language to None (will use default).")
+        # Example if mapping language string: lang_guid = lang_map.get(language, None)
+
+        print(f"DEBUG: Calling parent_object.create_pou: Name='{name}', Type={pou_type_enum}, Lang={lang_guid}")
+
+        # Call create_pou using keyword arguments based on create_pou.py
+        new_pou = parent_object.create_pou(
+            name=name,
+            type=pou_type_enum,
+            language=lang_guid # Pass None
+        )
+
+        if new_pou:
+            new_pou_name = getattr(new_pou, 'get_name', lambda: name)()
+            print(f"POU object created: {new_pou_name}")
+
+            # Save the project to persist the new POU based on create_pou.py
+            try:
+                print("DEBUG: Saving Project...")
+                project.save() # Use lowercase save
+                print("DEBUG: Project saved successfully after POU creation.")
+            except Exception as save_err:
+                print(f"ERROR: Failed to save Project after POU creation: {save_err}")
+                traceback.print_exc()
+                return {"status": "error", "message": f"Error saving Project after creating POU '{new_pou_name}': {save_err}"}
+
+            return {"status": "success", "message": f"POU '{new_pou_name}' created in '{parent_path}'. Project saved."}
+        else:
+             return {"status": "error", "message": f"Failed to create POU '{name}'. create_pou returned None."}
+
+    except Exception as e:
+        print(f"Error creating POU: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error creating POU: {e}"}
+
+def set_pou_code_command(args):
+    """Handles the 'set_pou_code' command."""
+    global active_project
+    project_file_path = args.get("project_file_path")
+    pou_path = args.get("pou_path")
+    declaration = args.get("declaration")
+    implementation = args.get("implementation")
+
+    if not all([project_file_path, pou_path]) or (declaration is None and implementation is None):
+         return {"status": "error", "message": "Missing arguments for set_pou_code"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_file_path)
+    if not project:
+        return {"status": "error", "message": f"Could not ensure project '{project_file_path}' is active to set POU code in."}
+
+    try:
+        print(f"Attempting to set code for POU '{pou_path}' in project: {project.path}")
+
+        # Find the POU object using the robust function
+        pou_object = find_object_by_path_robust(project, pou_path, "POU object")
+        if not pou_object:
+             return {"status": "error", "message": f"POU object not found: {pou_path}"}
+
+        success_decl = True
+        success_impl = True
+
+        # Use the actual CODESYS Scripting API to set the code based on set_pou_code.py
+        if declaration is not None:
+            print("Setting declaration code...")
+            if hasattr(pou_object, 'textual_declaration') and hasattr(pou_object.textual_declaration, 'replace'):
+                 try:
+                     pou_object.textual_declaration.replace(declaration)
+                     print("Set declaration text using replace().")
+                     declaration_updated = True
+                 except Exception as decl_err:
+                     print(f"ERROR: Failed to set declaration text: {decl_err}")
+                     traceback.print_exc()
+                     success_decl = False
+            else:
+                 print(f"WARN: Target '{getattr(pou_object, 'get_name', lambda: pou_path)()}' does not have accessible textual_declaration. Skipping declaration update.")
+                 success_decl = False # Consider this a failure if content was provided but couldn't be set
+
+        if implementation is not None:
+            print("Setting implementation code...")
+            if hasattr(pou_object, 'textual_implementation') and hasattr(pou_object.textual_implementation, 'replace'):
+                 try:
+                     pou_object.textual_implementation.replace(implementation)
+                     print("Set implementation text using replace().")
+                     implementation_updated = True
+                 except Exception as impl_err:
+                      print(f"ERROR: Failed to set implementation text: {impl_err}")
+                      traceback.print_exc()
+                      success_impl = False
+            else:
+                 print(f"WARN: Target '{getattr(pou_object, 'get_name', lambda: pou_path)()}' does not have accessible textual_implementation. Skipping implementation update.")
+                 success_impl = False # Consider this a failure if content was provided but couldn't be set
+
+
+        if success_decl and success_impl:
+            print("POU code set successfully.")
+            # Save the project to persist the code change based on set_pou_code.py
+            try:
+                print("DEBUG: Saving Project (after code change)...")
+                project.save() # Use lowercase save
+                print("DEBUG: Project saved successfully after code change.")
+            except Exception as save_err:
+                print(f"ERROR: Failed to save Project after setting code: {save_err}")
+                traceback.print_exc()
+                return {"status": "error", "message": f"Error saving Project after code change for '{pou_path}': {save_err}"}
+
+            return {"status": "success", "message": f"Code set for POU '{pou_path}'. Project saved."}
+        else:
+            return {"status": "error", "message": f"Failed to set code for POU '{pou_path}'. Declaration success: {success_decl}, Implementation success: {success_impl}"}
+
+    except Exception as e:
+        print(f"Error setting POU code: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error setting POU code: {e}"}
+
+def create_method_command(args):
+    """Handles the 'create_method' command."""
+    global active_project
+    project_file_path = args.get("project_file_path")
+    function_block_path = args.get("function_block_path")
+    name = args.get("name")
+    language = args.get("language") # Note: create_method.py passes None for language
+    # return_type = args.get("return_type") # create_method.py uses RETURN_TYPE placeholder
+
+    if not all([project_file_path, function_block_path, name]): # Language and return_type seem optional based on script
+         return {"status": "error", "message": "Missing required arguments for create_method"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_file_path)
+    if not project:
+        return {"status": "error", "message": f"Could not ensure project '{project_file_path}' is active to create method in."}
+
+    try:
+        print(f"Attempting to create Method '{name}' in Function Block '{function_block_path}' in project: {project.path}")
+
+        # Find the Function Block object using the robust function
+        fb_object = find_object_by_path_robust(project, function_block_path, "Function Block object")
+        if not fb_object:
+             return {"status": "error", "message": f"Function Block object not found: {function_block_path}"}
+
+        # Check if parent object supports creating methods (based on create_method.py)
+        if not hasattr(fb_object, 'create_method'):
+             return {"status": "error", "message": f"Parent object '{getattr(fb_object, 'get_name', lambda: str(fb_object))()}' of type {type(fb_object).__name__} does not support create_method."}
+
+        # Default language to None (usually ST) based on create_method.py
+        lang_guid = None
+        # Return type is also passed as None in the original script's call
+        actual_return_type = None # Assuming no return type is specified in the tool call args
+
+        print(f"DEBUG: Calling fb_object.create_method: Name='{name}', ReturnType={actual_return_type}, Lang={lang_guid}")
+
+        # Call the create_method method ON THE PARENT POU based on create_method.py
+        new_method_object = fb_object.create_method(
+            name=name,
+            return_type=actual_return_type, # Pass None
+            language=lang_guid # Pass None to use default
+        )
+
+        if new_method_object:
+            new_meth_name = getattr(new_method_object, 'get_name', lambda: name)()
+            print(f"Method object created: {new_meth_name}")
+
+            # Save the project to persist the new method object based on create_method.py
+            try:
+                print("DEBUG: Saving Project (after method creation)...")
+                project.save() # Use lowercase save
+                print("DEBUG: Project saved successfully after method creation.")
+            except Exception as save_err:
+                print(f"ERROR: Failed to save Project after creating method: {save_err}")
+                traceback.print_exc()
+                return {"status": "error", "message": f"Error saving Project after creating method '{name}': {save_err}"}
+
+            return {"status": "success", "message": f"Method '{new_meth_name}' created in '{function_block_path}'. Project saved."}
+        else:
+             return {"status": "error", "message": f"Failed to create method '{name}' under '{getattr(fb_object, 'get_name', lambda: function_block_path)() }'. create_method returned None."}
+
+    except Exception as e:
+        print(f"Error creating Method: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error creating Method: {e}"}
+
+def create_property_command(args):
+    """Handles the 'create_property' command."""
+    global active_project
+    project_file_path = args.get("project_file_path")
+    function_block_path = args.get("function_block_path")
+    name = args.get("name")
+    data_type = args.get("data_type")
+    # is_retain = args.get("is_retain", False) # Not used in create_property.py call
+    # is_persistent = args.get("is_persistent", False) # Not used in create_property.py call
+    # is_constant = args.get("is_constant", False) # Not used in create_property.py call
+    # initial_value = args.get("initial_value") # Not used in create_property.py call
+    # comment = args.get("comment") # Not used in create_property.py call
+
+    if not all([project_file_path, function_block_path, name, data_type]):
+         return {"status": "error", "message": "Missing required arguments for create_property"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_file_path)
+    if not project:
+        return {"status": "error", "message": f"Could not ensure project '{project_file_path}' is active to create property in."}
+
+    try:
+        print(f"Attempting to create Property '{name}' (Type: {data_type}) in Function Block '{function_block_path}' in project: {project.path}")
+
+        # Find the Function Block object using the robust function
+        fb_object = find_object_by_path_robust(project, function_block_path, "Function Block object")
+        if not fb_object:
+             return {"status": "error", "message": f"Function Block object not found: {function_block_path}"}
+
+        # Check if parent object supports creating properties (based on create_property.py)
+        if not hasattr(fb_object, 'create_property'):
+             return {"status": "error", "message": f"Parent object '{getattr(fb_object, 'get_name', lambda: str(fb_object))()}' of type {type(fb_object).__name__} does not support create_property."}
+
+        # Default language to None (usually ST) based on create_property.py
+        lang_guid = None
+        print(f"DEBUG: Calling create_property: Name='{name}', Type='{data_type}', Lang={lang_guid}")
+
+        # Call the create_property method ON THE PARENT POU based on create_property.py
+        # Note: The original script passes data_type as return_type and doesn't use optional args
+        new_property_object = fb_object.create_property(
+            name=name,
+            return_type=data_type, # Based on create_property.py's usage
+            language=lang_guid # Pass None to use default
+            # Optional arguments from tool schema are not used in the original script's API call
+            # is_retain=args.get("is_retain", False),
+            # is_persistent=args.get("is_persistent", False),
+            # is_constant=args.get("is_constant", False),
+            # initial_value=args.get("initial_value"),
+            # comment=args.get("comment")
+        )
+
+        if new_property_object:
+            new_prop_name = getattr(new_property_object, 'get_name', lambda: name)()
+            print(f"Property object created: {new_prop_name}")
+
+            # Save the project to persist the new property object based on create_property.py
+            try:
+                print("DEBUG: Saving Project (after property creation)...")
+                project.save() # Use lowercase save
+                print("DEBUG: Project saved successfully after property creation.")
+            except Exception as save_err:
+                print(f"ERROR: Failed to save Project after creating property: {save_err}")
+                traceback.print_exc()
+                return {"status": "error", "message": f"Error saving Project after creating property '{name}': {save_err}"}
+
+            return {"status": "success", "message": f"Property '{new_prop_name}' created in '{function_block_path}'. Project saved."}
+        else:
+             return {"status": "error", "message": f"Failed to create property '{name}' under '{getattr(fb_object, 'get_name', lambda: function_block_path)() }'. create_property returned None."}
+
+    except Exception as e:
+        print(f"Error creating Property: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error creating Property: {e}"}
+
+def compile_project_command(args):
+    """Handles the 'compile_project' command."""
+    global active_project
+    project_file_path = args.get("project_file_path")
+    if not project_file_path:
+        return {"status": "error", "message": "Missing 'project_file_path' argument for compile_project"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_file_path)
+    if not project:
+        return {"status": "error", "message": f"Could not ensure project '{project_file_path}' is active to compile."}
+
+    try:
+        print(f"Attempting to compile project: {project.path}")
+
+        target_app = None
+        app_name = "N/A"
+
+        # Try getting active application first based on compile_project.py
+        try:
+            if hasattr(project, 'active_application'):
+                target_app = project.active_application
+                if target_app:
+                    app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (Active)")()
+                    print(f"DEBUG: Found active application: {app_name}")
+        except Exception as active_err:
+            print(f"WARN: Could not get active application: {active_err}. Searching...")
+
+        # If no active app, search for the first one based on compile_project.py
+        if not target_app:
+            print("DEBUG: Searching for first compilable application...")
+            apps = []
+            try:
+                 # Search recursively through all project objects
+                 if hasattr(project, 'get_children'):
+                     all_children = project.get_children(True)
+                     for child in all_children:
+                          # Check using the marker property and if build method exists
+                          if hasattr(child, 'is_application') and child.is_application and hasattr(child, 'build'):
+                               app_name_found = getattr(child, 'get_name', lambda: "Unnamed App")()
+                               print(f"DEBUG: Found potential application object: {app_name_found}")
+                               apps.append(child)
+                               break # Take the first one found
+            except Exception as find_err: print(f"WARN: Error finding application object: {find_err}")
+
+            if not apps:
+                 return {"status": "error", "message": f"No compilable application found in project '{os.path.basename(project.path)}'"}
+            target_app = apps[0]
+            app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (First Found)")()
+            print(f"WARN: Compiling first found application: {app_name}")
+
+        print(f"DEBUG: Calling build() on app '{app_name}'...")
+        if not hasattr(target_app, 'build'):
+             return {"status": "error", "message": f"Selected object '{app_name}' is not an application or doesn't support build()."}
+
+        # Execute the build based on compile_project.py
+        target_app.build();
+        print(f"DEBUG: Build command executed for application '{app_name}'.")
+
+        # Note: Getting detailed compile output via scripting is not shown in compile_project.py.
+        # The original script relies on CODESYS UI or log output.
+        # We will return a success message and indicate that output might be in CODESYS logs.
+        compile_output = "Compilation initiated. Check CODESYS message view for details." # Default message
+
+        # In a real scenario, you might need to check message views or logs via scripting if available
+        # Example (conceptual):
+        # message_view = scriptengine.get_message_view() # Assuming such an API
+        # compile_output = message_view.get_messages() # Assuming method to get messages
+
+        print("Compile Initiated For Application: %s" % app_name)
+        print("In Project: %s" % os.path.basename(project.path))
+
+        return {"status": "success", "message": "Application compilation initiated.", "output": compile_output}
+
+    except Exception as e:
+        print(f"Error initiating compilation: {e}")
+        traceback.print_exc()
+        error_output = str(e) # Fallback to error message
+        # In a real scenario, you might need to check CODESYS message views via scripting
+        return {"status": "error", "message": f"Error initiating compilation: {e}", "output": error_output}
+
+
+def execute_script_command(args):
+    """Handles the 'execute_script' command by incorporating logic from specific scripts."""
+    script_name = args.get("script_name")
+    # script_args = args.get("script_args", {}) # Optional arguments for the script
+
+    if not script_name:
+        return {"status": "error", "message": "Missing 'script_name' argument for execute_script"}
+
+    print(f"Attempting to execute logic for script: {script_name}")
+
+    try:
+        # Incorporate logic from specific scripts here
+        if script_name == "check_status.py":
+             print("Executing logic for check_status.py")
+             # Logic based on check_status.py and ensure_project_open.py
+             status_data = {}
+             try:
+                 primary_project = scriptengine.projects.primary
+                 status_data['Scripting OK'] = 'True' # If script is running, scripting is likely OK
+                 status_data['Project Open'] = 'False'
+                 status_data['Project Name'] = 'None'
+                 status_data['Project Path'] = 'N/A'
+
+                 if primary_project:
+                     status_data['Project Open'] = 'True'
+                     try:
+                         status_data['Project Name'] = getattr(primary_project, 'get_name', lambda: os.path.basename(primary_project.path))()
+                         status_data['Project Path'] = os.path.abspath(primary_project.path)
+                     except Exception as name_path_err:
+                         print(f"WARN: Error getting project name/path in check_status logic: {name_path_err}")
+                         status_data['Project Name'] = 'Error'
+                         status_data['Project Path'] = 'Error'
+
+                 output_lines = [f"{key}: {value}" for key, value in status_data.items()]
+                 simulated_output = "\n".join(output_lines)
+                 print("check_status.py logic finished.")
+                 return {"status": "success", "message": "check_status logic executed.", "result": {"output": simulated_output}}
+
+             except Exception as check_err:
+                 print(f"Error in check_status.py logic: {check_err}")
+                 traceback.print_exc()
+                 return {"status": "error", "message": f"Error in check_status logic: {check_err}", "result": {"output": f"Error: {check_err}"}}
+
+        # Add logic for other scripts if needed, or handle them as separate commands
+        else:
+             return {"status": "error", "message": f"Execution of script logic for '{script_name}' is not implemented in the listener."}
+
+    except Exception as e:
+        print(f"Error executing script logic {script_name}: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error executing script logic {script_name}: {e}"}
+
+def get_project_structure_command(args):
+    """Handles the 'get_project_structure' command."""
+    global active_project
+    project_path = args.get("project_path")
+    if not project_path:
+        return {"status": "error", "message": "Missing 'project_path' argument for get_project_structure"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_path)
+    if not project:
+         return {"status": "error", "message": f"Could not ensure project '{project_path}' is active to get structure."}
+
+    try:
+        print(f"Attempting to get structure for project: {project.path}")
+
+        # Use the actual CODESYS Scripting API to get the project structure
+        # This requires traversing the project object hierarchy
+        structure_lines = []
+        structure_lines.append(f"Project: {getattr(project, 'get_name', lambda: os.path.basename(project.path))()}")
+
+        def traverse_objects(obj, indent_level):
+            indent = "  " * indent_level
+            try:
+                if hasattr(obj, 'get_children'):
+                    children = obj.get_children(False) # Get direct children
+                    for child in children:
+                        child_name = getattr(child, 'get_name', lambda: str(child))()
+                        child_type = type(child).__name__ # Get object type name
+                        line = f"{indent}{child_name} ({child_type})"
+                        # Add more details if available (e.g., POU type)
+                        if hasattr(child, 'pou_type'):
+                             line = f"{indent}POU: {child_name} ({getattr(child.pou_type, 'name', str(child.pou_type))})" # Assuming pou_type is an enum or has a name
+                        elif hasattr(child, 'is_application') and child.is_application:
+                             line = f"{indent}Application: {child_name}"
+                        elif hasattr(child, 'is_device') and child.is_device:
+                             line = f"{indent}Device: {child_name}"
+                        elif hasattr(child, 'is_folder') and child.is_folder:
+                             line = f"{indent}Folder: {child_name}"
+                        elif hasattr(child, 'is_library_manager') and child.is_library_manager:
+                             line = f"{indent}Library Manager"
+                        elif hasattr(child, 'is_task_configuration') and child.is_task_configuration:
+                             line = f"{indent}Task Configuration"
+                        # Add more type checks as needed
+
+                        structure_lines.append(line)
+                        traverse_objects(child, indent_level + 1) # Recurse
+
+            except Exception as traverse_err:
+                print(f"WARN: Error traversing object '{getattr(obj, 'get_name', lambda: str(obj))()}': {traverse_err}")
+                # Continue traversal for other siblings if possible
+
+        # Start traversal from the project's root children
+        if hasattr(project, 'get_children'):
+             traverse_objects(project, 1)
+        else:
+             print("WARN: Project object does not have 'get_children' method.")
+             structure_lines.append("  Could not retrieve project children.")
+
+
+        structure_text = "\n".join(structure_lines)
+
+        print("Project structure retrieved successfully.")
+        return {"status": "success", "message": "Project structure retrieved.", "structure": structure_text}
+
+    except Exception as e:
+        print(f"Error getting project structure: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error getting project structure: {e}"}
+
+def get_pou_code_command(args):
+    """Handles the 'get_pou_code' command."""
+    global active_project
+    project_path = args.get("project_path")
+    pou_path = args.get("pou_path")
+    if not project_path or not pou_path:
+        return {"status": "error", "message": "Missing arguments for get_pou_code"}
+
+    # Ensure the correct project is active
+    project = ensure_project_is_active(project_path)
+    if not project:
+         return {"status": "error", "message": f"Could not ensure project '{project_path}' is active to get POU code."}
+
+    try:
+        print(f"Attempting to get code for POU '{pou_path}' in project: {project.path}")
+
+        # Find the POU object using the robust function
+        pou_object = find_object_by_path_robust(project, pou_path, "POU object")
+        if not pou_object:
+             return {"status": "error", "message": f"POU object not found: {pou_path}"}
+
+        declaration_code = ""
+        implementation_code = ""
+
+        # Use the actual CODESYS Scripting API to get the code based on set_pou_code.py
+        if hasattr(pou_object, 'textual_declaration') and pou_object.textual_declaration is not None:
+             try:
+                 # Assuming textual_declaration has a .content or similar property to get text
+                 # The set_pou_code.py uses .replace(), not clear how to GET the text.
+                 # Let's assume there's a .content or just casting to string works.
+                 declaration_code = str(pou_object.textual_declaration) # Attempt to cast to string
+                 print("Retrieved declaration code.")
+             except Exception as decl_get_err:
+                 print(f"WARN: Could not get declaration text: {decl_get_err}")
+                 declaration_code = f"// Error retrieving declaration: {decl_get_err}"
+                 traceback.print_exc()
+        else:
+             print(f"Object '{getattr(pou_object, 'get_name', lambda: pou_path)()}' does not appear to have a textual_declaration.")
+
+
+        if hasattr(pou_object, 'textual_implementation') and pou_object.textual_implementation is not None:
+             try:
+                 # Assuming textual_implementation has a .content or similar property to get text
+                 implementation_code = str(pou_object.textual_implementation) # Attempt to cast to string
+                 print("Retrieved implementation code.")
+             except Exception as impl_get_err:
+                 print(f"WARN: Could not get implementation text: {impl_get_err}")
+                 implementation_code = f"// Error retrieving implementation: {impl_get_err}"
+                 traceback.print_exc()
+        else:
+             print(f"Object '{getattr(pou_object, 'get_name', lambda: pou_path)()}' does not appear to have a textual_implementation.")
+
+
+        # Format the output similar to the original server.ts resource
+        code_text = f"// ----- Declaration -----\n{declaration_code}\n\n// ----- Implementation -----\n{implementation_code}"
+
+        print("POU code retrieved successfully.")
+        return {"status": "success", "message": "POU code retrieved.", "code": code_text}
+
+    except Exception as e:
+        print(f"Error getting POU code: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error getting POU code: {e}"}
+
+
+# Add more command handler functions here for other operations (write, export, etc.)
+# Implement login/logout/read_variable using ScriptOnline based on the stub file provided earlier
+
+def login_command(args):
+    """Handles the 'login' command using ScriptOnline."""
+    global online_app, online_device
+    # project_file_path = args.get("project_file_path") # Login might be project specific
+
+    # Ensure a project is open and an application/device is selected if necessary
+    # This part is highly dependent on your project structure and how you identify the target
+    # For simplicity, let's assume we can create a default online application for the active project
+    project = scriptengine.projects.primary # Use the primary project
+    if not project:
+         return {"status": "error", "message": "No active project to login with."}
+
+    try:
+        print("Attempting to create online application and device...")
+        # Use the actual ScriptOnline API based on the stub file
+        # Need to get the application object from the project
+        target_app = None
+        if hasattr(project, 'active_application'):
+             target_app = project.active_application
+        if not target_app and hasattr(project, 'find'):
+             apps = project.find("Application", True)
+             if apps: target_app = apps[0]
+
+        if not target_app:
+             return {"status": "error", "message": "No application found in the active project to login with."}
+
+        online_app = ScriptOnline.create_online_application(application=target_app) # Pass the target application
+        # Need to get the device object from the application or project
+        target_device = None
+        if hasattr(target_app, 'device'): # Assuming application has a device attribute
+             target_device = target_app.device
+        elif hasattr(project, 'device'): # Assuming project has a device attribute
+             target_device = project.device
+        # If still no device, try finding one
+        if not target_device and hasattr(project, 'find'):
+             devices = project.find("Device", True)
+             if devices: target_device = devices[0]
+
+
+        if not target_device:
+             # Clean up online_app if created
+             if online_app: online_app.Dispose(); online_app = None
+             return {"status": "error", "message": "No device found in the active project to login with."}
+
+
+        online_device = ScriptOnline.create_online_device(device=target_device) # Pass the target device
+
+        if online_app and online_device:
+            print("Online application and device objects created.")
+            # Perform the login
+            # Use OnlineChangeOption from scriptengine
+            change_option = scriptengine.OnlineChangeOption.Try # Example option
+            delete_foreign_apps = False # Example option
+            print(f"Attempting to login with change_option={change_option}, delete_foreign_apps={delete_foreign_apps}...")
+            online_app.login(change_option, delete_foreign_apps) # Use lowercase login
+
+            # Check if login was successful (conceptual - stub has is_logged_in property)
+            # The login() method itself might raise an exception on failure.
+            # If it returns without exception, assume success for now.
+            # if online_app.is_logged_in: # Check property after calling login()
+            print("Login operation called. Check online status via resource.")
+            return {"status": "success", "message": "Login operation initiated. Check project status resource for online status."}
+            # else:
+            #      print("Login failed (is_logged_in is False after call).")
+            #      # Clean up if login fails
+            #      if online_app: online_app.Dispose(); online_app = None
+            #      if online_device: online_device.Dispose(); online_device = None
+            #      return {"status": "error", "message": "Login failed."}
+
+        else:
+             print("Failed to create online application or device objects.")
+             # Clean up
+             if online_app: online_app.Dispose(); online_app = None
+             if online_device: online_device.Dispose(); online_device = None
+             return {"status": "error", "message": "Failed to create online application or device objects."}
+
+    except Exception as e:
+        print(f"Error during login: {e}")
+        traceback.print_exc()
+        # Clean up if login fails
+        if online_app:
+            try: online_app.Dispose()
+            except: pass
+            online_app = None
+        if online_device:
+             try: online_device.Dispose()
+             except: pass
+             online_device = None
+        return {"status": "error", "message": f"Error during login: {e}"}
+
+def logout_command(args):
+    """Handles the 'logout' command using ScriptOnline."""
+    global online_app, online_device
+    try:
+        print("Attempting to logout and dispose online objects...")
+        if online_app:
+            online_app.logout() # Use lowercase logout
+            online_app.Dispose() # Use uppercase Dispose
+            online_app = None
+            print("Online application logged out and disposed.")
+        if online_device:
+             online_device.Dispose() # Use uppercase Dispose
+             online_device = None
+             print("Online device disposed.")
+
+        if online_app is None and online_device is None:
+             return {"status": "success", "message": "Logged out and disposed online objects."}
+        else:
+             return {"status": "error", "message": "Failed to fully dispose online objects."}
+
+    except Exception as e:
+        print(f"Error during logout: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error during logout: {e}"}
+
+def read_variable_command(args):
+    """Handles the 'read_variable' command using ScriptOnline."""
+    global online_app
+    expression = args.get("expression")
+    if not expression:
+        return {"status": "error", "message": "Missing 'expression' argument for read_variable"}
+
+    if online_app is None:
+        return {"status": "error", "message": "Not logged in. Cannot read variable."}
+
+    try:
+        print(f"Attempting to read variable: {expression}")
+        # Use the actual ScriptOnlineApplication API based on the stub file
+        # Assuming read_value returns the value as a string
+        value = online_app.read_value(expression) # Use lowercase read_value
+        print(f"Read value for {expression}: {value}")
+        return {"status": "success", "value": value}
+    except Exception as e:
+        print(f"Error reading variable {expression}: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error reading variable {expression}: {e}"}
+
+# Add more command handler functions here for other operations (write, export, etc.)
+# Implement write_variable using set_prepared_value and write_prepared_values
+def write_variable_command(args):
+    """Handles the 'write_variable' command using ScriptOnline."""
+    global online_app
+    expression = args.get("expression")
+    value = args.get("value")
+    if not expression or value is None: # Value can be 0, False, empty string, so check for None
+        return {"status": "error", "message": "Missing 'expression' or 'value' argument for write_variable"}
+
+    if online_app is None:
+        return {"status": "error", "message": "Not logged in. Cannot write variable."}
+
+    try:
+        print(f"Attempting to write variable: {expression} with value: {value}")
+        # Use the actual ScriptOnlineApplication API based on the stub file
+        # Prepare the value first
+        online_app.set_prepared_value(expression, str(value)) # set_prepared_value expects string value
+        print(f"Prepared value for {expression} = {value}. Attempting to write prepared values...")
+        # Write all prepared values
+        online_app.write_prepared_values() # Use lowercase write_prepared_values
+        print("write_prepared_values operation called.")
+        # Note: write_prepared_values might raise ValuesFailedException on failure
+
+        return {"status": "success", "message": "Write operation initiated. Check online status and messages."}
+    except Exception as e:
+        print(f"Error writing variable {expression}: {e}")
+        traceback.print_exc()
+        # Check if it's a ValuesFailedException to get failed expressions
+        if isinstance(e, scriptengine.ValuesFailedException): # Assuming ValuesFailedException is in scriptengine
+             failed_expr = getattr(e, 'failed_expressions', ['Unknown']) # Get failed expressions if available
+             return {"status": "error", "message": f"Error writing variable {expression}: {e}", "failed_expressions": failed_expr}
+        else:
+             return {"status": "error", "message": f"Error writing variable {expression}: {e}"}
+
+
+def process_command(command_data):
+    """Parses and processes incoming commands."""
+    try:
+        command_obj = json.loads(command_data)
+        command_type = command_obj.get("command")
+        args = command_obj.get("args", {})
+
+        print(f"Processing command type: {command_type}")
+
+        # Map command types to handler functions
+        command_handlers = {
+            "exit": lambda a: {"status": "success", "message": "Shutdown requested."}, # Handled in handle_client loop break
+            "open_project": open_project_command,
+            "create_project": create_project_command,
+            "save_project": save_project_command,
+            "create_pou": create_pou_command,
+            "set_pou_code": set_pou_code_command,
+            "create_method": create_method_command,
+            "create_property": create_property_command,
+            "compile_project": compile_project_command,
+            "execute_script": execute_script_command, # Keep for check_status example
+            "get_project_structure": get_project_structure_command,
+            "get_pou_code": get_pou_code_command,
+            "login": login_command, # Add login command handler
+            "logout": logout_command, # Add logout command handler
+            "read_variable": read_variable_command, # Add read_variable command handler
+            "write_variable": write_variable_command, # Add write_variable command handler
+            # Add more mappings here for other tools/resources
+        }
+
+        handler = command_handlers.get(command_type)
+
+        if handler:
+            return handler(args)
+        else:
+            return {"status": "error", "message": f"Unknown command: {command_type}"}
+
+    except json.JSONDecodeError:
+        print(f"Error decoding JSON: {command_data}")
+        traceback.print_exc()
+        return {"status": "error", "message": "Invalid JSON command received."}
+    except Exception as e:
+        print(f"Error processing command: {e}")
+        traceback.print_exc()
+        return {"status": "error", "message": f"Error processing command: {e}"}
+
+def handle_client(conn):
+    """Handles communication with a single client connection."""
+    print(f"Connected by {conn.getpeername()}")
+    socket_buffer = "" # Buffer for incomplete messages
+    try:
+        while True:
+            # Receive data
+            data = conn.recv(4096)
+            if not data:
+                print("Client disconnected.")
+                break
+            socket_buffer += data.decode('utf-8')
+
+            # Process messages delimited by newline
+            while '\n' in socket_buffer:
+                message, socket_buffer = socket_buffer.split('\n', 1)
+                if not message.strip(): # Skip empty lines
+                    continue
+
+                print(f"Received message: {message}")
+                response = process_command(message)
+                print(f"Sending response: {response}")
+                # Send response as JSON string followed by a newline
+                conn.sendall((json.dumps(response) + '\n').encode('utf-8'))
+
+                # Check for the exit command response to signal shutdown
+                if response.get("command") == "exit" and response.get("status") == "success":
+                     print("Exit command processed. Closing client connection.")
+                     return # Exit the handler loop
+
+    except Exception as e:
+        print(f"Error handling client: {e}")
+        traceback.print_exc()
+    finally:
+        print(f"Closing connection from {conn.getpeername()}")
+        conn.close()
+        # In a single-client-expected scenario, you might want to signal
+        # the main listener loop to exit here if the client disconnects unexpectedly.
+        # For this example, the listener loop continues to accept new connections.
+
+
+def run_listener():
+    """Starts the socket listener."""
+    global online_app, online_device, active_project
+    server_socket = None
+    try:
+        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reusing the address
+        server_socket.bind((HOST, PORT))
+        server_socket.listen(1) # Listen for only 1 incoming connection (assuming one MCP server client)
+        print(f"CODESYS Listener Script listening on {HOST}:{PORT}")
+
+        # Keep accepting connections until an external shutdown signal is received
+        # A more robust implementation might use a flag or event for shutdown
+        # triggered by the 'exit' command processed in handle_client.
+        # For this example, the loop continues indefinitely until script termination.
+        while True:
+            print("Waiting for a connection...")
+            conn, addr = server_socket.accept()
+            # Handle the client connection directly in the main thread
+            # This simplifies managing the active_project and online_app globals
+            # If concurrent requests were needed, threading would be necessary,
+            # but managing shared state (active_project, online_app) would be complex.
+            handle_client(conn)
+
+    except Exception as e:
+        print(f"Error in listener: {e}")
+        traceback.print_exc()
+    finally:
+        print("Listener shutting down.")
+        if server_socket:
+            server_socket.close()
+        # Ensure online objects and project are disposed on script exit
+        if online_app:
+            try:
+                online_app.Dispose() # Use uppercase Dispose
+            except:
+                pass
+            online_app = None
+        if online_device:
+             try:
+                 online_device.Dispose() # Use uppercase Dispose
+             except:
+                 pass
+             online_device = None
+        if active_project:
+             try:
+                 # Check if the project object has a close method before calling
+                 if hasattr(active_project, 'Close'): # Assuming Close method exists and is uppercase
+                     active_project.Close()
+                 elif hasattr(active_project, 'close'): # Check for lowercase too
+                      active_project.close()
+             except:
+                 pass
+             active_project = None
+        print("Online objects and project disposed.")
+
+
+if __name__ == "__main__":
+    print("CODESYS Listener Script starting...")
+    # You might need to add CODESYS initialization code here if necessary
+    # e.g., setting up the environment, opening a default project on startup
+    # The server.ts will handle launching CODESYS with this script.
+
+    run_listener()
+
+    print("CODESYS Listener Script finished.")