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

package/dist/scripts/start_session.py

@@ -1,809 +0,0 @@
-import sys, os, time, tempfile, traceback
-
-# 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()
-    
-# Import scriptengine
-try:
-    import scriptengine as script_engine
-    print("Successfully imported scriptengine module")
-except ImportError:
-    # Log the error and continue - we'll handle this gracefully 
-    print("Error importing scriptengine. This script must be run within CODESYS environment.")
-    script_engine = None
-
-# Print Python and platform info
-print("Python version: {0}.{1}.{2}".format(sys.version_info[0], sys.version_info[1], sys.version_info[2]))
-print("Platform: {0}".format(sys.platform))
-print("Executable: {0}".format(sys.executable))
-
-# 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")
-POLL_INTERVAL = 0.1  # seconds (faster polling for better responsiveness)
-MAX_INACTIVITY_TIME = 600  # seconds (10 minutes of inactivity before auto-shutdown)
-
-def setup_session_dir():
-    """Create the session directory and initial files"""
-    try:
-        # Clean up any existing session first
-        if os.path.exists(SESSION_DIR):
-            try:
-                # Try to read existing session state
-                if os.path.exists(SESSION_STATE_FILE):
-                    try:
-                        with open(SESSION_STATE_FILE, 'r') as f:
-                            old_state = json.load(f)
-                            print("Cleaning up previous session (ID: {0})".format(old_state.get('session_id', 'unknown')))
-                    except:
-                        pass
-                
-                # Remove all files in the directory
-                for filename in os.listdir(SESSION_DIR):
-                    filepath = os.path.join(SESSION_DIR, filename)
-                    try:
-                        if os.path.isfile(filepath):
-                            os.unlink(filepath)
-                    except Exception as e:
-                        print("Error removing file {0}: {1}".format(filepath, e))
-            except Exception as e:
-                print("Error cleaning up previous session: {0}".format(e))
-        
-        # Create session directory
-        if not os.path.exists(SESSION_DIR):
-            os.makedirs(SESSION_DIR)
-            
-        # Initialize session state
-        session_id = str(time.time()) + "_" + str(os.getpid())
-        session_state = {
-            "active": True,
-            "session_id": session_id,
-            "start_time": time.time(),
-            "last_activity": time.time(),
-            "status": "running",
-            "project_open": False,
-            "project_name": "",
-            "project_path": "",
-            "version": "1.0"
-        }
-        
-        # Write session state
-        with open(SESSION_STATE_FILE, 'w') as f:
-            json.dump(session_state, f, indent=2)
-        
-        # Create empty command file
-        with open(COMMAND_FILE, 'w') as f:
-            json.dump({"status": "ready", "command": None, "timestamp": time.time()}, f, indent=2)
-        
-        # Create empty result file
-        with open(RESULT_FILE, 'w') as f:
-            json.dump({"status": "none", "result": None, "timestamp": time.time()}, f, indent=2)
-        
-        # Create lock file
-        with open(SESSION_LOCK_FILE, 'w') as f:
-            f.write(str(time.time()))
-        
-        print("Session directory setup at: {0}".format(SESSION_DIR))
-        print("Session ID: {0}".format(session_id))
-        return True
-    except Exception as e:
-        print("Failed to set up session directory: {0}".format(e))
-        print("{0}: Session setup failed - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
-        return False
-
-def update_session_state(status="running"):
-    """Update the session state file with current CODESYS state"""
-    try:
-        # Get current state
-        project_open = False
-        project_name = "No project open"
-        project_path = "N/A"
-        
-        # Check if script_engine was properly imported
-        if script_engine is None:
-            print("Warning: scriptengine not available, cannot get project info")
-        else:
-            # Try to get primary project
-            try:
-                primary_project = script_engine.projects.primary
-                if primary_project:
-                    project_open = True
-                    try:
-                        project_path = os.path.normcase(os.path.abspath(primary_project.path))
-                        try:
-                            project_name = primary_project.get_name()
-                            if not project_name:
-                                project_name = "Unnamed (path: {0})".format(os.path.basename(project_path))
-                        except:
-                            project_name = "Unnamed (path: {0})".format(os.path.basename(project_path))
-                    except Exception as e_path:
-                        project_path = "N/A (Error: {0})".format(str(e_path))
-                        project_name = "Unnamed (Path Error)"
-            except Exception as e:
-                print("Error accessing script_engine.projects: {0}".format(str(e)))
-                traceback.print_exc()
-        
-        # Read current state file
-        try:
-            with open(SESSION_STATE_FILE, 'r') as f:
-                session_state = json.load(f)
-        except (FileNotFoundError, json.JSONDecodeError):
-            # State file doesn't exist or is invalid, create a new one
-            session_id = str(time.time()) + "_" + str(os.getpid())
-            session_state = {
-                "active": True,
-                "session_id": session_id,
-                "start_time": time.time(),
-                "status": status,
-                "version": "1.0"
-            }
-        
-        # Update state
-        session_state["project_open"] = project_open
-        session_state["project_name"] = project_name
-        session_state["project_path"] = project_path
-        session_state["last_update"] = time.time()
-        session_state["status"] = status
-        
-        # Write updated state
-        with open(SESSION_STATE_FILE, 'w') as f:
-            json.dump(session_state, f, indent=2)
-            
-        return True
-    except Exception as e:
-        print("Failed to update session state: {0}".format(e))
-        traceback.print_exc()
-        return False
-
-def execute_command(command_data):
-    """Execute a command"""
-    try:
-        cmd_type = command_data.get("type", "execute_script")
-        script = command_data.get("script", "")
-        cmd_id = command_data.get("id", "unknown")
-        
-        result = {
-            "id": cmd_id,
-            "success": False,
-            "output": "",
-            "error": ""
-        }
-        
-        print("Executing command type: {0} with ID: {1}".format(cmd_type, cmd_id))
-        sys.stdout.flush()
-        
-        if cmd_type == "execute_script" and script:
-            # Execute the script in the current CODESYS context
-            try:
-                # Log the first few lines of the script for debugging
-                script_lines = script.split("\n")
-                print("Script preview (first 3 lines):")
-                for i in range(min(3, len(script_lines))):
-                    print("  {0}: {1}".format(i+1, script_lines[i]))
-                sys.stdout.flush()
-                
-                print("Script length: {0} chars, {1} lines".format(len(script), len(script_lines)))
-                sys.stdout.flush()
-                
-                # Check for critical operations in the script
-                has_project_create = "copy2" in script or "shutil.copy" in script
-                has_project_open = "projects.open" in script
-                
-                if has_project_create:
-                    print("WARNING: Script contains project creation operations - these may require special handling")
-                    sys.stdout.flush()
-                
-                if has_project_open:
-                    print("WARNING: Script contains project open operations - these may require special handling")
-                    sys.stdout.flush()
-                
-                # Create a temporary globals dictionary with the current globals
-                # This allows us to isolate the script execution somewhat
-                local_globals = globals().copy()
-                
-                # Capture output by temporarily replacing stdout/stderr
-                # Use custom approach compatible with IronPython 2.7
-                try:
-                    import StringIO as io_module  # Python 2.x
-                except ImportError:
-                    import io as io_module  # Python 3.x
-                
-                stdout_buffer = io_module.StringIO()
-                stderr_buffer = io_module.StringIO()
-                
-                # Save original stdout and stderr
-                old_stdout = sys.stdout
-                old_stderr = sys.stderr
-                
-                print("Execution starting - output will be captured")
-                sys.stdout.flush()
-                
-                # Replace with our buffers
-                sys.stdout = stdout_buffer
-                sys.stderr = stderr_buffer
-                
-                # For critical operations that might deadlock, we need to be more careful
-                if has_project_create or has_project_open:
-                    # For project creation/opening, we'll execute the script with some guards
-                    print("Executing critical script with guards...")
-                    try:
-                        # Execute the script in a more controlled manner with debugging
-                        print("DEBUG-CRITICAL: About to execute project creation/open script")
-                        # First write project ops directly to the result file to prevent hanging
-                        try:
-                            with open(RESULT_FILE, 'w') as f:
-                                result_data = {
-                                    "status": "in_progress",
-                                    "result": {
-                                        "id": command.get("id", "unknown"),
-                                        "success": False,
-                                        "output": "Project creation/opening operation in progress...",
-                                    },
-                                    "timestamp": time.time()
-                                }
-                                json.dump(result_data, f, indent=2)
-                            print("DEBUG-CRITICAL: Created preliminary result file")
-                        except Exception as rf_err:
-                            print("DEBUG-CRITICAL: Error creating preliminary result: {0}".format(rf_err))
-                        
-                        # Now execute the script
-                        exec(script, local_globals)
-                        print("DEBUG-CRITICAL: Script executed successfully")
-                    except Exception as e:
-                        # If the script fails, capture the error
-                        print("ERROR in critical script execution: {0}".format(e))
-                        traceback.print_exc()
-                    
-                    print("Critical script execution finished")
-                else:
-                    # For normal scripts, execute normally
-                    try:
-                        # Execute the script
-                        exec(script, local_globals)
-                    finally:
-                        # No special handling needed
-                        pass
-                
-                # Restore original stdout and stderr
-                sys.stdout = old_stdout
-                sys.stderr = old_stderr
-                
-                print("Execution completed - processing results")
-                sys.stdout.flush()
-                
-                # Get the captured output
-                stdout_output = stdout_buffer.getvalue()
-                stderr_output = stderr_buffer.getvalue()
-                
-                # Special handling for project creation - always check if we can find success markers
-                # in partial output even if script appears to have issues
-                if has_project_create:
-                    # Look specifically for the file copy completion
-                    if "File copy VERIFIED - file exists at destination" in stdout_output or "DEBUG: File copy complete" in stdout_output:
-                        print("IMPORTANT: Detected successful file copy in project creation script")
-                        project_path = ""
-                        
-                        # Try to extract the project path from output
-                        project_path_match = None
-                        for line in stdout_output.split('\n'):
-                            if "DEBUG: Target Path =" in line:
-                                project_path_match = line.split('=')[1].strip()
-                                break
-                        
-                        if project_path_match:
-                            project_path = project_path_match
-                            print("IMPORTANT: Found project path: {0}".format(project_path))
-                            
-                            # Even if there was an error later (like opening), consider this a partial success
-                            if "Error creating project" in stdout_output and "currently in use" in stdout_output:
-                                print("IMPORTANT: Project file was created but couldn't be opened due to 'in use' error")
-                                # Combine success and error markers
-                                stdout_output += "\nSCRIPT_SUCCESS: Project file was created at {0} but could not be opened because it is in use by another CODESYS instance.".format(project_path)
-                                result["success"] = True
-                
-                # Check for success/error markers
-                if SCRIPT_SUCCESS_MARKER in stdout_output or SCRIPT_SUCCESS_MARKER in stderr_output:
-                    result["success"] = True
-                    print("Found success marker in script output")
-                elif SCRIPT_ERROR_MARKER in stdout_output or SCRIPT_ERROR_MARKER in stderr_output:
-                    result["success"] = False
-                    print("Found error marker in script output")
-                else:
-                    # No explicit markers, assume success for non-critical operations
-                    # For critical operations like project creation, be more careful
-                    if has_project_create:
-                        if "File copy complete" in stdout_output:
-                            result["success"] = True
-                            print("Project creation seems successful based on file copy completion")
-                        else:
-                            result["success"] = False
-                            print("Project creation script lacks success markers and file copy confirmation")
-                    else:
-                        result["success"] = True
-                        print("No markers found in script output, assuming success")
-                
-                # Tally output length to check if output is reasonable
-                print("Output length: stdout={0} chars, stderr={1} chars".format(
-                    len(stdout_output), len(stderr_output)))
-                
-                result["output"] = stdout_output
-                if stderr_output:
-                    result["error"] = stderr_output
-                
-                sys.stdout.flush()
-            
-            except Exception as e:
-                traceback.print_exc()
-                sys.stdout.flush()
-                result["success"] = False
-                result["error"] = "Error executing script: {0}\n{1}".format(str(e), traceback.format_exc())
-                result["output"] = "{0}: {1}".format(SCRIPT_ERROR_MARKER, str(e))
-        
-        elif cmd_type == "stop":
-            # Stop command received
-            result["success"] = True
-            result["output"] = "{0}: Session stopping".format(SCRIPT_SUCCESS_MARKER)
-            
-            # Update session state to mark as stopping
-            update_session_state("stopping")
-            
-            # Return the result and signal to stop the loop
-            return result, True
-        
-        elif cmd_type == "ping":
-            # Simple ping command to check if session is alive
-            result["success"] = True
-            result["output"] = "{0}: Session is active".format(SCRIPT_SUCCESS_MARKER)
-        
-        else:
-            result["success"] = False
-            result["error"] = "Unknown command type: {0}".format(cmd_type)
-            result["output"] = "{0}: Unknown command type: {1}".format(SCRIPT_ERROR_MARKER, cmd_type)
-        
-        # Update session state after command execution
-        update_session_state()
-        
-        return result, False
-        
-    except Exception as e:
-        traceback.print_exc()
-        return {
-            "id": command_data.get("id", "unknown"),
-            "success": False,
-            "output": "{0}: Command execution failed".format(SCRIPT_ERROR_MARKER),
-            "error": "{0}\n{1}".format(str(e), traceback.format_exc())
-        }, False
-
-def check_command():
-    """Check if there is a new command to execute"""
-    try:
-        # If command file doesn't exist, return immediately
-        if not os.path.exists(COMMAND_FILE):
-            print("Command file does not exist at {0}".format(COMMAND_FILE))
-            return False
-            
-        # Read the command file
-        try:
-            print("Reading command file: {0}".format(COMMAND_FILE))
-            with open(COMMAND_FILE, 'r') as f:
-                file_content = f.read()
-                print("Raw command file content: {0}".format(file_content[:100] if len(file_content) > 100 else file_content))
-                
-                # Check if file is empty
-                if not file_content.strip():
-                    print("Command file is empty, resetting")
-                    command_data = {"status": "ready", "command": None, "timestamp": time.time()}
-                    with open(COMMAND_FILE, 'w') as fw:
-                        json.dump(command_data, fw, indent=2)
-                    return False
-                
-                # Try to parse JSON
-                try:
-                    command_data = json.loads(file_content)
-                except Exception as json_err:
-                    print("Error parsing command file JSON: {0}".format(json_err))
-                    # If command file is corrupted, reset it
-                    command_data = {"status": "ready", "command": None, "timestamp": time.time()}
-                    with open(COMMAND_FILE, 'w') as fw:
-                        json.dump(command_data, fw, indent=2)
-                    return False
-        except Exception as read_err:
-            print("Error reading command file: {0}".format(read_err))
-            # Reset the command file
-            command_data = {"status": "ready", "command": None, "timestamp": time.time()}
-            try:
-                with open(COMMAND_FILE, 'w') as fw:
-                    json.dump(command_data, fw, indent=2)
-            except Exception as write_err:
-                print("Error writing reset command file: {0}".format(write_err))
-            return False
-        
-        # Check if there's a new command
-        status = command_data.get("status")
-        command = command_data.get("command")
-        
-        print("Command status: {0}".format(status))
-        if command:
-            print("Command found: {0}".format(command.get("type", "unknown")))
-            
-        if status == "pending" and command:
-            print("Processing pending command...")
-            
-            try:
-                # Mark as processing
-                command_data["status"] = "processing"
-                with open(COMMAND_FILE, 'w') as f:
-                    json.dump(command_data, f, indent=2)
-                print("Updated command status to 'processing'")
-                
-                # Update session state to busy
-                update_session_state("busy")
-                
-                # Execute the command
-                print("Executing command: {0}".format(command.get("type", "unknown")))
-                sys.stdout.flush()  # Ensure output is flushed before potentially long-running operation
-                result, stop_requested = execute_command(command)
-                print("Command execution complete, stop_requested: {0}".format(stop_requested))
-                
-                # Write the result with extra safety measures
-                result_data = {
-                    "status": "complete",
-                    "result": result,
-                    "timestamp": time.time()
-                }
-                
-                print("Writing result to {0}".format(RESULT_FILE))
-                sys.stdout.flush()
-                
-                # First, write to a temporary file to avoid corruption
-                temp_result_file = RESULT_FILE + ".tmp"
-                try:
-                    with open(temp_result_file, 'w') as f:
-                        json.dump(result_data, f, indent=2)
-                    print("Temporary result file written successfully")
-                    
-                    # If temporary write succeeded, move to the real file
-                    if os.path.exists(temp_result_file):
-                        # On Windows, we may need to remove the destination first
-                        if os.path.exists(RESULT_FILE):
-                            try:
-                                os.remove(RESULT_FILE)
-                            except Exception as rm_err:
-                                print("Warning: Could not remove existing result file: {0}".format(rm_err))
-                        
-                        # Now rename the temp file to the real file
-                        os.rename(temp_result_file, RESULT_FILE)
-                        print("Result file updated successfully")
-                    else:
-                        print("ERROR: Temporary result file not found after writing!")
-                        # Try direct write as fallback
-                        with open(RESULT_FILE, 'w') as f:
-                            json.dump(result_data, f, indent=2)
-                except Exception as result_err:
-                    print("ERROR writing result file: {0}".format(result_err))
-                    traceback.print_exc()
-                    sys.stdout.flush()
-                    
-                    # Desperate attempt - try direct write with minimal content
-                    try:
-                        with open(RESULT_FILE, 'w') as f:
-                            f.write('{"status":"complete","result":{"id":"' + 
-                                   result["id"] + '","success":' + 
-                                   ('true' if result["success"] else 'false') + 
-                                   ',"output":"Result writing failed but operation completed"},"timestamp":' + 
-                                   str(time.time()) + '}')
-                        print("Emergency minimal result file written")
-                    except Exception as emergency_err:
-                        print("CRITICAL ERROR: Even emergency result write failed: {0}".format(emergency_err))
-                
-                sys.stdout.flush()
-                
-                # Reset command file
-                command_data = {
-                    "status": "ready",
-                    "command": None,
-                    "timestamp": time.time()
-                }
-                
-                print("Resetting command file")
-                with open(COMMAND_FILE, 'w') as f:
-                    json.dump(command_data, f, indent=2)
-                
-                # Update session state to running again
-                if not stop_requested:
-                    update_session_state("running")
-                
-                # Update last activity time
-                update_last_activity()
-                
-                return stop_requested
-            except Exception as cmd_err:
-                print("Error processing command: {0}".format(cmd_err))
-                traceback.print_exc()
-                sys.stdout.flush()  # Ensure error output is flushed
-                
-                # Try to reset the command file
-                try:
-                    command_data = {
-                        "status": "ready",
-                        "command": None,
-                        "timestamp": time.time()
-                    }
-                    with open(COMMAND_FILE, 'w') as f:
-                        json.dump(command_data, f, indent=2)
-                except Exception as reset_err:
-                    print("Error resetting command file: {0}".format(reset_err))
-                
-                # Try to restore session state
-                try:
-                    update_session_state("running")
-                except Exception as state_err:
-                    print("Error updating session state: {0}".format(state_err))
-                    
-                return False
-        
-        return False
-    except Exception as e:
-        print("Error in check_command: {0}".format(e))
-        traceback.print_exc()
-        sys.stdout.flush()  # Ensure error output is flushed
-        return False
-
-def update_last_activity():
-    """Update the last activity timestamp in the session state"""
-    try:
-        if os.path.exists(SESSION_STATE_FILE):
-            with open(SESSION_STATE_FILE, 'r') as f:
-                state = json.load(f)
-            
-            state["last_activity"] = time.time()
-            
-            with open(SESSION_STATE_FILE, 'w') as f:
-                json.dump(state, f, indent=2)
-    except Exception as e:
-        print("Error updating last activity: {0}".format(e))
-
-def check_inactivity_timeout():
-    """Check if session has been inactive for too long"""
-    try:
-        if os.path.exists(SESSION_STATE_FILE):
-            with open(SESSION_STATE_FILE, 'r') as f:
-                state = json.load(f)
-            
-            last_activity = state.get("last_activity", state.get("start_time", time.time()))
-            current_time = time.time()
-            
-            if (current_time - last_activity) > MAX_INACTIVITY_TIME:
-                print("Session inactive for {0:.1f} seconds, shutting down".format(current_time - last_activity))
-                return True
-        
-        return False
-    except Exception as e:
-        print("Error checking inactivity timeout: {0}".format(e))
-        return False
-
-def command_loop():
-    """Main loop to check for and execute commands"""
-    stop_requested = False
-    last_state_update = time.time()
-    loop_count = 0
-    last_heartbeat = time.time()
-    start_time = time.time()
-    error_count = 0  # Track consecutive errors
-    
-    # Maximum session runtime to prevent infinite hanging (8 hours)
-    max_session_runtime = 60 * 60 * 8
-    
-    print("Starting command loop...")
-    print("Command file: {0}".format(COMMAND_FILE))
-    print("Result file: {0}".format(RESULT_FILE))
-    print("Session lock file: {0}".format(SESSION_LOCK_FILE))
-    print("Session state file: {0}".format(SESSION_STATE_FILE))
-    print("Poll interval: {0} seconds".format(POLL_INTERVAL))
-    print("Max inactivity time: {0} seconds".format(MAX_INACTIVITY_TIME))
-    print("Max session runtime: {0} hours".format(max_session_runtime / 3600))
-    sys.stdout.flush()  # Ensure initialization output is visible immediately
-    
-    # Set up initial session state files
-    try:
-        # Create initial command file if it doesn't exist
-        if not os.path.exists(COMMAND_FILE):
-            with open(COMMAND_FILE, 'w') as f:
-                json.dump({
-                    "status": "ready",
-                    "command": None,
-                    "timestamp": time.time()
-                }, f, indent=2)
-            print("Created initial command file")
-            
-        # Create initial result file if it doesn't exist
-        if not os.path.exists(RESULT_FILE):
-            with open(RESULT_FILE, 'w') as f:
-                json.dump({
-                    "status": "none",
-                    "result": None,
-                    "timestamp": time.time()
-                }, f, indent=2)
-            print("Created initial result file")
-            sys.stdout.flush()
-    except Exception as setup_err:
-        print("Error setting up initial files: {0}".format(setup_err))
-        traceback.print_exc()
-        sys.stdout.flush()
-    
-    print("Entering main command loop...")
-    sys.stdout.flush()
-    
-    while not stop_requested:
-        try:
-            loop_count += 1
-            current_time = time.time()
-            
-            # Check for absolute maximum session runtime to prevent infinite hanging
-            session_runtime = current_time - start_time
-            if session_runtime > max_session_runtime:
-                print("SAFETY: Maximum session run time of {0} hours reached".format(max_session_runtime / 3600))
-                print("SAFETY: This is to prevent CODESYS from hanging indefinitely")
-                print("SAFETY: Session will now terminate")
-                update_session_state("timeout")
-                sys.stdout.flush()
-                stop_requested = True
-                break
-            
-            # Update session lock file to indicate we're alive
-            with open(SESSION_LOCK_FILE, 'w') as f:
-                f.write(str(current_time))
-            
-            # Print heartbeat message every 60 seconds
-            if current_time - last_heartbeat > 60:
-                print("Command loop heartbeat - still alive (iteration {0})".format(loop_count))
-                print("Session running for {0:.1f} minutes".format(session_runtime / 60))
-                last_heartbeat = current_time
-                sys.stdout.flush()
-            
-            # Check for new commands
-            stop_requested = check_command()
-            if stop_requested:
-                print("Stop was requested by a command")
-                sys.stdout.flush()
-            
-            # Check for inactivity timeout
-            if check_inactivity_timeout():
-                print("Session timeout due to inactivity")
-                update_session_state("timeout")
-                stop_requested = True
-                sys.stdout.flush()
-                
-            # Periodically update session state (every 30 seconds)
-            if (current_time - last_state_update) > 30:
-                print("Periodic session state update")
-                update_session_state()
-                last_state_update = current_time
-                sys.stdout.flush()
-            
-            # Reset error count on successful iteration
-            error_count = 0
-            
-            # Sleep for a bit
-            time.sleep(POLL_INTERVAL)
-        
-        except Exception as e:
-            print("Error in command loop: {0}".format(e))
-            traceback.print_exc()
-            sys.stdout.flush()
-            
-            # Increment error count
-            error_count += 1
-            
-            # If we're getting repeated errors, consider breaking the loop
-            if error_count > 10:
-                print("SAFETY: Too many consecutive errors ({0}), stopping session".format(error_count))
-                update_session_state("error")
-                sys.stdout.flush()
-                stop_requested = True
-            else:
-                # Sleep for a bit before retrying
-                time.sleep(POLL_INTERVAL)
-    
-    print("Command loop stopped after {0} iterations".format(loop_count))
-    sys.stdout.flush()
-
-# Main script
-def main():
-    try:
-        print("Starting CODESYS automation session...")
-        sys.stdout.flush()
-        
-        # Setup session directory and files
-        print("Setting up session directory...")
-        sys.stdout.flush()
-        if not setup_session_dir():
-            print("Failed to set up session directory")
-            sys.stdout.flush()
-            sys.exit(1)
-        
-        # Update initial session state
-        print("Updating initial session state...")
-        sys.stdout.flush()
-        update_session_state()
-        
-        # Start command loop
-        print("{0}: CODESYS session started".format(SCRIPT_SUCCESS_MARKER))
-        sys.stdout.flush()
-        command_loop()
-        
-        # Update final state
-        update_session_state("stopped")
-        
-        print("{0}: CODESYS session stopped cleanly".format(SCRIPT_SUCCESS_MARKER))
-        sys.stdout.flush()
-        sys.exit(0)
-    except Exception as e:
-        print("Error in session: {0}".format(e))
-        print("{0}: Session failed - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
-        traceback.print_exc()
-        sys.stdout.flush()
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()