@codesys/mcp-toolkit 1.1.5 → 1.1.6

package/codesys_scripts/listener_script.py

@@ -1,1539 +0,0 @@
-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.")