@codesys/mcp-toolkit 1.2.1 → 1.3.0

package/dist/scripts/start_session.py

@@ -0,0 +1,278 @@
+import sys, os, json, time, tempfile
+import scriptengine as script_engine
+
+# Define markers for script results
+SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
+SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
+
+# Session state 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.5  # seconds
+
+def setup_session_dir():
+    """Create the session directory and initial files"""
+    try:
+        # Create session directory
+        if not os.path.exists(SESSION_DIR):
+            os.makedirs(SESSION_DIR)
+            
+        # Initialize session state
+        session_state = {
+            "active": True,
+            "session_id": str(time.time()),
+            "start_time": time.time(),
+            "status": "running",
+            "project_open": False,
+            "project_name": "",
+            "project_path": ""
+        }
+        
+        # Write session state
+        with open(SESSION_STATE_FILE, 'w') as f:
+            json.dump(session_state, f)
+        
+        # Create empty command file
+        with open(COMMAND_FILE, 'w') as f:
+            json.dump({"status": "ready", "command": None, "timestamp": time.time()}, f)
+        
+        # Create empty result file
+        with open(RESULT_FILE, 'w') as f:
+            json.dump({"status": "none", "result": None, "timestamp": time.time()}, f)
+        
+        # Create lock file
+        with open(SESSION_LOCK_FILE, 'w') as f:
+            f.write(str(time.time()))
+        
+        print(f"Session directory setup at: {SESSION_DIR}")
+        return True
+    except Exception as e:
+        print(f"Failed to set up session directory: {e}")
+        print(f"{SCRIPT_ERROR_MARKER}: Session setup failed - {str(e)}")
+        return False
+
+def update_session_state(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"
+        
+        primary_project = script_engine.projects.primary
+        if primary_project:
+            project_open = True
+            try:
+                project_path = os.path.normcase(os.path.abspath(primary_project.path))
+                try:
+                    project_name = primary_project.get_name()
+                    if not project_name:
+                        project_name = f"Unnamed (path: {os.path.basename(project_path)})"
+                except:
+                    project_name = f"Unnamed (path: {os.path.basename(project_path)})"
+            except Exception as e_path:
+                project_path = f"N/A (Error: {e_path})"
+                project_name = "Unnamed (Path Error)"
+        
+        # Read current state file
+        with open(SESSION_STATE_FILE, 'r') as f:
+            session_state = json.load(f)
+        
+        # Update state
+        session_state["project_open"] = project_open
+        session_state["project_name"] = project_name
+        session_state["project_path"] = project_path
+        session_state["last_update"] = time.time()
+        session_state["status"] = status
+        
+        # Write updated state
+        with open(SESSION_STATE_FILE, 'w') as f:
+            json.dump(session_state, f)
+            
+        return True
+    except Exception as e:
+        print(f"Failed to update session state: {e}")
+        return False
+
+def execute_command(command_data):
+    """Execute a command"""
+    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": ""
+        }
+        
+        if cmd_type == "execute_script" and script:
+            # Execute the script in the current CODESYS context
+            try:
+                # Capture output by redirecting stdout/stderr
+                import io
+                from contextlib import redirect_stdout, redirect_stderr
+                
+                stdout_buffer = io.StringIO()
+                stderr_buffer = io.StringIO()
+                
+                with redirect_stdout(stdout_buffer), redirect_stderr(stderr_buffer):
+                    # Execute the script
+                    exec(script, globals())
+                
+                # Get the captured output
+                stdout_output = stdout_buffer.getvalue()
+                stderr_output = stderr_buffer.getvalue()
+                
+                # Check for success/error markers
+                if SCRIPT_SUCCESS_MARKER in stdout_output or SCRIPT_SUCCESS_MARKER in stderr_output:
+                    result["success"] = True
+                elif SCRIPT_ERROR_MARKER in stdout_output or SCRIPT_ERROR_MARKER in stderr_output:
+                    result["success"] = False
+                else:
+                    # No explicit markers, assume success
+                    result["success"] = True
+                
+                result["output"] = stdout_output
+                if stderr_output:
+                    result["error"] = stderr_output
+            
+            except Exception as e:
+                result["success"] = False
+                result["error"] = f"Error executing script: {str(e)}"
+                result["output"] = f"{SCRIPT_ERROR_MARKER}: {str(e)}"
+        
+        elif cmd_type == "stop":
+            # Stop command received
+            result["success"] = True
+            result["output"] = f"{SCRIPT_SUCCESS_MARKER}: Session stopping"
+            
+            # Update session state to mark as stopping
+            update_session_state("stopping")
+            
+            # Return the result and signal to stop the loop
+            return result, True
+        
+        else:
+            result["success"] = False
+            result["error"] = f"Unknown command type: {cmd_type}"
+            result["output"] = f"{SCRIPT_ERROR_MARKER}: Unknown command type: {cmd_type}"
+        
+        # Update session state after command execution
+        update_session_state()
+        
+        return result, False
+        
+    except Exception as e:
+        return {
+            "id": command_data.get("id", "unknown"),
+            "success": False,
+            "output": f"{SCRIPT_ERROR_MARKER}: Command execution failed",
+            "error": str(e)
+        }, False
+
+def check_command():
+    """Check if there is a new command to execute"""
+    try:
+        # Read the command file
+        with open(COMMAND_FILE, 'r') as f:
+            command_data = json.load(f)
+        
+        # Check if there's a new command
+        if command_data.get("status") == "pending" and command_data.get("command"):
+            # Extract the command
+            command = command_data.get("command")
+            
+            # Mark as processing
+            command_data["status"] = "processing"
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump(command_data, f)
+            
+            # Execute the command
+            result, stop_requested = execute_command(command)
+            
+            # Write the result
+            result_data = {
+                "status": "complete",
+                "result": result,
+                "timestamp": time.time()
+            }
+            
+            with open(RESULT_FILE, 'w') as f:
+                json.dump(result_data, f)
+            
+            # Reset command file
+            command_data = {
+                "status": "ready",
+                "command": None,
+                "timestamp": time.time()
+            }
+            
+            with open(COMMAND_FILE, 'w') as f:
+                json.dump(command_data, f)
+            
+            return stop_requested
+        
+        return False
+    except Exception as e:
+        print(f"Error checking command: {e}")
+        return False
+
+def command_loop():
+    """Main loop to check for and execute commands"""
+    stop_requested = False
+    
+    print(f"Starting command loop...")
+    print(f"Command file: {COMMAND_FILE}")
+    print(f"Result file: {RESULT_FILE}")
+    
+    while not stop_requested:
+        try:
+            # Update session lock file to indicate we're alive
+            with open(SESSION_LOCK_FILE, 'w') as f:
+                f.write(str(time.time()))
+            
+            # Check for new commands
+            stop_requested = check_command()
+            
+            # Sleep for a bit
+            time.sleep(POLL_INTERVAL)
+        
+        except Exception as e:
+            print(f"Error in command loop: {e}")
+            # Sleep for a bit
+            time.sleep(POLL_INTERVAL)
+    
+    print("Command loop stopped.")
+
+# Main script
+def main():
+    try:
+        # Setup session directory and files
+        if not setup_session_dir():
+            sys.exit(1)
+        
+        # Update initial session state
+        update_session_state()
+        
+        # Start command loop
+        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session started")
+        command_loop()
+        
+        # Update final state
+        update_session_state("stopped")
+        
+        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session stopped cleanly")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error in session: {e}")
+        print(f"{SCRIPT_ERROR_MARKER}: Session failed - {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/dist/scripts/stop_session.py

@@ -0,0 +1,117 @@
+import sys, os, json, time
+import tempfile
+
+# 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")
+
+def stop_session():
+    """Stop a running CODESYS session"""
+    try:
+        # Check if session directory exists
+        if not os.path.exists(SESSION_DIR):
+            print(f"{SCRIPT_ERROR_MARKER}: No session directory found at {SESSION_DIR}")
+            return False
+
+        # Check if session state file exists
+        if not os.path.exists(SESSION_STATE_FILE):
+            print(f"{SCRIPT_ERROR_MARKER}: No session state file found at {SESSION_STATE_FILE}")
+            return False
+
+        # Read session state
+        with open(SESSION_STATE_FILE, 'r') as f:
+            try:
+                session_state = json.load(f)
+            except json.JSONDecodeError:
+                print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
+                return False
+
+        # Check if session is active
+        if not session_state.get('active', False):
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is already stopped")
+            return True
+
+        # Check if command file exists
+        if not os.path.exists(COMMAND_FILE):
+            print(f"{SCRIPT_ERROR_MARKER}: Command file not found at {COMMAND_FILE}")
+            return False
+
+        # Create stop command
+        stop_command = {
+            "id": f"stop_{int(time.time())}",
+            "type": "stop",
+            "timestamp": time.time()
+        }
+
+        # Write command to file
+        command_data = {
+            "status": "pending",
+            "command": stop_command,
+            "timestamp": time.time()
+        }
+
+        with open(COMMAND_FILE, 'w') as f:
+            json.dump(command_data, f)
+
+        print(f"Stop command sent to session")
+
+        # Wait for result (with timeout)
+        timeout = 10  # seconds
+        start_time = time.time()
+        result_received = False
+
+        while not result_received 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') == stop_command['id']:
+                            result_received = True
+                            print(f"Session stop result: {result.get('output', 'No output')}")
+                            break
+            except Exception as e:
+                print(f"Error reading result: {e}")
+                time.sleep(0.5)
+
+        # Update session state to indicate it's stopped
+        with open(SESSION_STATE_FILE, 'r') as f:
+            session_state = json.load(f)
+            
+        session_state['active'] = False
+        session_state['status'] = "stopped"
+        session_state['end_time'] = time.time()
+
+        with open(SESSION_STATE_FILE, 'w') as f:
+            json.dump(session_state, f)
+
+        if result_received:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session stopped successfully")
+        else:
+            print(f"{SCRIPT_ERROR_MARKER}: Timeout waiting for session to stop")
+
+        return result_received
+
+    except Exception as e:
+        print(f"{SCRIPT_ERROR_MARKER}: Error stopping session - {str(e)}")
+        return False
+
+# Main script
+if __name__ == "__main__":
+    if stop_session():
+        sys.exit(0)
+    else:
+        sys.exit(1)