@codesys/mcp-toolkit 1.5.8 → 2.0.0-alpha.0

package/dist/scripts/get_project_structure.py

@@ -1,72 +0,0 @@
-import sys, scriptengine as script_engine, os, traceback
-
-# Import ensure_project_open function from the template
-# This will be prepended by the script loader
-def ensure_project_open(target_project_path):
-    # Function implementation will be included from ensure_project_open.py
-    pass
-
-def get_object_structure(obj, indent=0, max_depth=10): # Add max_depth
-    lines = []; indent_str = "  " * indent
-    if indent > max_depth:
-        lines.append("%s- Max recursion depth reached." % indent_str)
-        return lines
-    try:
-        name = "Unnamed"; obj_type = type(obj).__name__
-        guid_str = ""
-        folder_str = ""
-        try:
-            name = getattr(obj, 'get_name', lambda: "Unnamed")() or "Unnamed" # Safer get_name
-            if hasattr(obj, 'guid'): guid_str = " {%s}" % obj.guid
-            if hasattr(obj, 'is_folder') and obj.is_folder: folder_str = " [Folder]"
-        except Exception as name_err:
-             print("WARN: Error getting name/guid/folder status for an object: %s" % name_err)
-             name = "!!! Error Getting Name !!!"
-
-        lines.append("%s- %s (%s)%s%s" % (indent_str, name, obj_type, folder_str, guid_str))
-
-        # Get children only if the object potentially has them
-        children = []
-        can_have_children = hasattr(obj, 'get_children') and (
-            not hasattr(obj, 'is_folder') or # If it's not clear if it's a folder (e.g., project root)
-            (hasattr(obj, 'is_folder') and obj.is_folder) or # If it is a folder
-             # Add known container types explicitly, check marker interfaces too
-             hasattr(obj, 'is_project') or hasattr(obj, 'is_application') or hasattr(obj, 'is_device') or hasattr(obj,'is_pou')
-        )
-
-        if can_have_children:
-            try:
-                children = obj.get_children(False)
-                # print("DEBUG: %s has %d children" % (name, len(children))) # Verbose
-            except Exception as get_child_err:
-                lines.append("%s  ERROR getting children: %s" % (indent_str, get_child_err))
-                # traceback.print_exc() # Optional
-
-        for child in children:
-            lines.extend(get_object_structure(child, indent + 1, max_depth)) # Recurse
-
-    except Exception as e:
-        lines.append("%s- Error processing node: %s" % (indent_str, e))
-        traceback.print_exc() # Print detailed error for this node
-    return lines
-    
-try:
-    print("DEBUG: Getting structure for: %s" % PROJECT_FILE_PATH)
-    primary_project = ensure_project_open(PROJECT_FILE_PATH)
-    project_name = os.path.basename(PROJECT_FILE_PATH)
-    print("DEBUG: Getting structure for project: %s" % project_name)
-    # Use the project object obtained from ensure_project_open
-    structure_list = get_object_structure(primary_project, max_depth=15) # Set a reasonable depth
-    structure_output = "\\n".join(structure_list)
-    # Ensure markers are printed distinctly
-    print("\\n--- PROJECT STRUCTURE START ---")
-    print(structure_output)
-    print("--- PROJECT STRUCTURE END ---\\n")
-    print("SCRIPT_SUCCESS: Project structure retrieved.")
-    sys.exit(0)
-except Exception as e:
-    detailed_error = traceback.format_exc()
-    error_message = "Error getting structure for %s: %s\\n%s" % (PROJECT_FILE_PATH, e, detailed_error)
-    print(error_message)
-    print("SCRIPT_ERROR: %s" % error_message)
-    sys.exit(1)

package/dist/scripts/open_project.py

@@ -1,25 +0,0 @@
-import sys, scriptengine as script_engine, os, traceback
-
-# Import ensure_project_open function from the template
-# This will be prepended by the script loader
-def ensure_project_open(target_project_path):
-    # Function implementation will be included from ensure_project_open.py
-    pass
-
-try:
-    project = ensure_project_open(PROJECT_FILE_PATH)
-    # Get name from object if possible, otherwise use path basename
-    proj_name = "Unknown"
-    try:
-        if project: proj_name = project.get_name() or os.path.basename(PROJECT_FILE_PATH)
-        else: proj_name = os.path.basename(PROJECT_FILE_PATH) + " (ensure_project_open returned None?)"
-    except Exception:
-        proj_name = os.path.basename(PROJECT_FILE_PATH) + " (name retrieval failed)"
-    print("Project Opened: %s" % proj_name)
-    print("SCRIPT_SUCCESS: Project opened successfully.")
-    sys.exit(0)
-except Exception as e:
-    error_message = "Error opening project %s: %s" % (PROJECT_FILE_PATH, e)
-    print(error_message)
-    traceback.print_exc()
-    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/save_project.py

@@ -1,29 +0,0 @@
-import sys, scriptengine as script_engine, os, traceback
-
-# Import ensure_project_open function from the template
-# This will be prepended by the script loader
-def ensure_project_open(target_project_path):
-    # Function implementation will be included from ensure_project_open.py
-    pass
-
-try:
-    primary_project = ensure_project_open(PROJECT_FILE_PATH)
-    # Get name from object if possible, otherwise use path basename
-    project_name = "Unknown"
-    try:
-        if primary_project: project_name = primary_project.get_name() or os.path.basename(PROJECT_FILE_PATH)
-        else: project_name = os.path.basename(PROJECT_FILE_PATH) + " (ensure_project_open returned None?)"
-    except Exception:
-        project_name = os.path.basename(PROJECT_FILE_PATH) + " (name retrieval failed)"
-
-    print("DEBUG: Saving project: %s (%s)" % (project_name, PROJECT_FILE_PATH))
-    primary_project.save()
-    print("DEBUG: project.save() executed.")
-    print("Project Saved: %s" % project_name)
-    print("SCRIPT_SUCCESS: Project saved successfully.")
-    sys.exit(0)
-except Exception as e:
-    error_message = "Error saving project %s: %s" % (PROJECT_FILE_PATH, e)
-    print(error_message)
-    traceback.print_exc()
-    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/session_status.py

@@ -1,281 +0,0 @@
-import sys, os, time, traceback
-import tempfile
-
-# Import JSON handling for IronPython 2.7 compatibility
-try:
-    import json
-except ImportError:
-    # For IronPython 2.7, we need to use simplejson instead
-    try:
-        import simplejson as json
-    except ImportError:
-        print("Neither json nor simplejson could be imported. Check IronPython installation.")
-        # Provide a minimal fallback implementation for basic needs
-        class DummyJson:
-            @staticmethod
-            def load(file_obj):
-                content = file_obj.read()
-                # Very basic parsing for our limited needs
-                if content.strip().startswith("{") and content.strip().endswith("}"):
-                    result = {}
-                    parts = content.strip()[1:-1].split(",")
-                    for part in parts:
-                        if ":" in part:
-                            k, v = part.split(":", 1)
-                            k = k.strip().strip('"\'')
-                            v = v.strip().strip('"\'')
-                            result[k] = v
-                    return result
-                return {}
-                
-            @staticmethod
-            def loads(s):
-                if s.strip().startswith("{") and s.strip().endswith("}"):
-                    result = {}
-                    parts = s.strip()[1:-1].split(",")
-                    for part in parts:
-                        if ":" in part:
-                            k, v = part.split(":", 1)
-                            k = k.strip().strip('"\'')
-                            v = v.strip().strip('"\'')
-                            result[k] = v
-                    return result
-                return {}
-                
-            @staticmethod
-            def dump(obj, file_obj, indent=None):
-                if isinstance(obj, dict):
-                    pairs = []
-                    for k, v in obj.items():
-                        if isinstance(v, str):
-                            pairs.append('"{0}": "{1}"'.format(k, v))
-                        else:
-                            pairs.append('"{0}": {1}'.format(k, v))
-                    file_obj.write("{" + ", ".join(pairs) + "}")
-                else:
-                    file_obj.write(str(obj))
-        
-        json = DummyJson()
-
-# Define markers for script results
-SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
-SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
-
-# Session state and command files
-SESSION_DIR = os.path.join(tempfile.gettempdir(), "codesys_session")
-SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
-COMMAND_FILE = os.path.join(SESSION_DIR, "command.json")
-RESULT_FILE = os.path.join(SESSION_DIR, "result.json")
-SESSION_LOCK_FILE = os.path.join(SESSION_DIR, "session.lock")
-
-# Print key information at start
-print("Session status check script starting")
-print("tempdir: {0}".format(tempfile.gettempdir()))
-print("SESSION_DIR: {0}".format(SESSION_DIR))
-print("SESSION_STATE_FILE: {0}".format(SESSION_STATE_FILE))
-print("COMMAND_FILE: {0}".format(COMMAND_FILE))
-print("RESULT_FILE: {0}".format(RESULT_FILE))
-print("SESSION_LOCK_FILE: {0}".format(SESSION_LOCK_FILE))
-
-def check_session_status():
-    """Check the status of a CODESYS session"""
-    try:
-        # Check if session directory exists
-        if not os.path.exists(SESSION_DIR):
-            print("{0}: No session active. Session directory not found.".format(SCRIPT_SUCCESS_MARKER))
-            return False
-
-        # Check if session state file exists
-        if not os.path.exists(SESSION_STATE_FILE):
-            print("{0}: No session active. Session state file not found.".format(SCRIPT_SUCCESS_MARKER))
-            return False
-
-        # Read session state
-        try:
-            with open(SESSION_STATE_FILE, 'r') as f:
-                session_state = json.load(f)
-        except json.JSONDecodeError:
-            print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
-            return False
-        except Exception as e:
-            print("{0}: Error reading session state file: {1}".format(SCRIPT_ERROR_MARKER, str(e)))
-            return False
-
-        # Check if session is active
-        active = session_state.get('active', False)
-        status = session_state.get('status', 'unknown')
-        
-        # If the status indicates the session is not active, return immediately
-        if not active or status in ['stopped', 'error', 'stopping', 'timeout']:
-            print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
-            return False
-        
-        # Check for session running too long (> 8 hours)
-        start_time = session_state.get('start_time', 0)
-        current_time = time.time()
-        uptime = current_time - start_time if start_time else 0
-        max_allowed_uptime = 60 * 60 * 8  # 8 hours in seconds
-        
-        if uptime > max_allowed_uptime:
-            print("WARNING: Session has been running for {0:.1f} hours, exceeding the 8-hour safety limit".format(uptime / 3600))
-            
-            # Update session state to indicate timeout due to excessive runtime
-            try:
-                session_state['status'] = 'timeout'
-                session_state['active'] = False
-                session_state['error_reason'] = 'Maximum runtime exceeded'
-                
-                with open(SESSION_STATE_FILE, 'w') as f:
-                    json.dump(session_state, f, indent=2)
-                    
-                print("Updated session state to timeout due to excessive runtime")
-                print("{0}: Session is not active (exceeded maximum runtime)".format(SCRIPT_SUCCESS_MARKER))
-                return False
-            except Exception as e:
-                print("Error updating session state: {0}".format(e))
-        
-        # Check session lock file to see if it's been updated recently
-        lock_is_stale = False
-        if os.path.exists(SESSION_LOCK_FILE):
-            try:
-                with open(SESSION_LOCK_FILE, 'r') as f:
-                    lock_time = float(f.read().strip())
-                    time_diff = current_time - lock_time
-                    
-                    # If lock file hasn't been updated in 30 seconds, session might be dead
-                    if time_diff > 30:
-                        print("WARNING: Session lock file is stale by {0:.1f} seconds".format(time_diff))
-                        lock_is_stale = True
-            except Exception as e:
-                print("Error reading lock file: {0}".format(e))
-                lock_is_stale = True
-        else:
-            print("WARNING: Session lock file not found")
-            lock_is_stale = True
-        
-        # If the lock file is stale but other checks suggest the session is active,
-        # we'll perform a ping test to be sure
-        ping_success = False
-        if status in ["running", "busy"]:
-            # Try to ping the session
-            try:
-                # Check if command file exists
-                if os.path.exists(COMMAND_FILE):
-                    print("Sending ping command to verify session...")
-                    
-                    # Create ping command
-                    ping_command = {
-                        "id": "ping_{0}".format(int(time.time())),
-                        "type": "ping",  # Use specific ping command type
-                        "timestamp": time.time()
-                    }
-                    
-                    # Write command to file with pretty-printing
-                    command_data = {
-                        "status": "pending",
-                        "command": ping_command,
-                        "timestamp": time.time()
-                    }
-                    
-                    with open(COMMAND_FILE, 'w') as f:
-                        json.dump(command_data, f, indent=2)
-                    
-                    # Wait for result (with short timeout)
-                    timeout = 5  # seconds
-                    start_time = time.time()
-                    
-                    while not ping_success and (time.time() - start_time) < timeout:
-                        # Check if result file exists
-                        if not os.path.exists(RESULT_FILE):
-                            time.sleep(0.5)
-                            continue
-                        
-                        try:
-                            with open(RESULT_FILE, 'r') as f:
-                                result_data = json.load(f)
-                                
-                                if result_data.get("status") == "complete" and result_data.get("result"):
-                                    result = result_data.get("result")
-                                    if result.get('id') == ping_command['id'] and result.get('success', False):
-                                        ping_success = True
-                                        print("Ping successful, session is responsive")
-                                        break
-                        except Exception as e:
-                            print("Error reading result: {0}".format(e))
-                            time.sleep(0.5)
-                    
-                    if not ping_success:
-                        print("WARNING: Session did not respond to ping within {0} seconds".format(timeout))
-                        
-                        # Reset command file since ping failed
-                        try:
-                            command_data = {
-                                "status": "ready",
-                                "command": None,
-                                "timestamp": time.time()
-                            }
-                            
-                            with open(COMMAND_FILE, 'w') as f:
-                                json.dump(command_data, f, indent=2)
-                                
-                            print("Reset command file after failed ping")
-                        except Exception as e:
-                            print("Error resetting command file: {0}".format(e))
-                else:
-                    print("WARNING: Command file not found, cannot ping session")
-            except Exception as e:
-                print("Error during ping test: {0}".format(e))
-                traceback.print_exc()
-        
-        # Make final determination based on all checks
-        session_active = active and (not lock_is_stale or ping_success) and status in ["running", "busy"]
-        
-        # Build status message
-        project_info = ""
-        if session_state.get('project_open', False):
-            project_name = session_state.get('project_name', 'Unknown')
-            project_path = session_state.get('project_path', 'Unknown')
-            project_info = ", Project: {0} ({1})".format(project_name, project_path)
-        
-        # Include session info
-        session_id = session_state.get('session_id', 'Unknown')
-        uptime_str = "{0:.0f} seconds".format(uptime) if uptime < 60 else (
-            "{0:.1f} minutes".format(uptime/60) if uptime < 3600 else 
-            "{0:.1f} hours".format(uptime/3600)
-        )
-        
-        if session_active:
-            print("{0}: Session is active (ID: {1}, Status: {2}, Uptime: {3}{4})".format(SCRIPT_SUCCESS_MARKER, session_id, status, uptime_str, project_info))
-            return True
-        else:
-            # If we get here, session may be in a state where files exist but process is dead
-            if active and status in ["running", "busy"] and lock_is_stale and not ping_success:
-                print("{0}: Session appears to be zombie (ID: {1}, Status: {2} but unresponsive)".format(SCRIPT_SUCCESS_MARKER, session_id, status))
-                # Update session state to error so it will be considered inactive
-                try:
-                    session_state['status'] = 'error'
-                    session_state['active'] = False
-                    session_state['error_reason'] = 'Unresponsive to ping'
-                    
-                    with open(SESSION_STATE_FILE, 'w') as f:
-                        json.dump(session_state, f, indent=2)
-                        
-                    print("Updated session state to error due to unresponsiveness")
-                except Exception as e:
-                    print("Error updating session state: {0}".format(e))
-            else:
-                print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
-                
-            return False
-
-    except Exception as e:
-        print("{0}: Error checking session status - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
-        traceback.print_exc()
-        return False
-
-# Main script
-if __name__ == "__main__":
-    if check_session_status():
-        sys.exit(0)
-    else:
-        sys.exit(1)

package/dist/scripts/set_pou_code.py

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