@codesys/mcp-toolkit 1.2.4 → 1.4.0

package/.claude/settings.local.json

@@ -18,7 +18,9 @@
       "Bash(npm publish:*)",
       "Bash(npm publish:*)",
       "Bash(ls:*)",
-      "Bash(ls:*)"
+      "Bash(ls:*)",
+      "Bash(mkdir:*)",
+      "Bash(mkdir:*)"
     ],
     "deny": []
   }

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2025-05-02
+### Added
+- Implemented persistent session management functionality
+- Added support for keeping CODESYS open between commands
+- Created file-based IPC for script execution in existing CODESYS instance
+- Improved session reliability with health checks and automatic recovery
+- Added session timeout after 10 minutes of inactivity
+- Created detailed documentation for session management features
+
+## [1.3.0] - 2025-05-02
+### Changed
+- Refactored codebase for improved reliability and maintainability
+- Enhanced error handling in Python script templates
+
 ## [1.2.4] - 2025-05-02 
 ### Fixed
 - Fully disabled session management to prevent operations appearing to succeed but not actually running

package/dist/scripts/session_status.py

@@ -1,168 +1,189 @@
-import sys, os, json, time, tempfile
+import sys, os, json, time, traceback
+import tempfile
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
 
-# Session state file and pipes
+# 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_PIPE = os.path.join(SESSION_DIR, "command_pipe")
-RESULT_PIPE = os.path.join(SESSION_DIR, "result_pipe")
+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 check_session_status():
-    """Check the status of a CODESYS session by reading the state file"""
+    """Check the status of a CODESYS session"""
     try:
         # Check if session directory exists
         if not os.path.exists(SESSION_DIR):
-            return {
-                "session_exists": False,
-                "active": False,
-                "message": "No session directory found"
-            }
-            
-        # Check if state file exists
+            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session directory not found.")
+            return False
+
+        # Check if session state file exists
         if not os.path.exists(SESSION_STATE_FILE):
-            return {
-                "session_exists": True,
-                "active": False,
-                "message": "Session directory exists but no state file found"
-            }
-            
-        # Read the state file
-        with open(SESSION_STATE_FILE, 'r') as f:
-            session_state = json.load(f)
-            
-        # Check if pipes exist
-        pipes_exist = os.path.exists(COMMAND_PIPE) and os.path.exists(RESULT_PIPE)
-        
-        # Get session duration if available
-        start_time = session_state.get("start_time", 0)
-        if start_time > 0:
-            current_time = time.time()
-            duration_secs = int(current_time - start_time)
-            hours, remainder = divmod(duration_secs, 3600)
-            minutes, seconds = divmod(remainder, 60)
-            duration = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-        else:
-            duration = "unknown"
-            
-        # Last update time
-        last_update = session_state.get("last_update", 0)
-        last_update_str = "never"
-        if last_update > 0:
-            seconds_since_update = int(time.time() - last_update)
-            if seconds_since_update < 60:
-                last_update_str = f"{seconds_since_update} seconds ago"
-            elif seconds_since_update < 3600:
-                last_update_str = f"{seconds_since_update // 60} minutes ago"
-            else:
-                last_update_str = f"{seconds_since_update // 3600} hours ago"
-                
-        return {
-            "session_exists": True,
-            "active": session_state.get("active", False),
-            "project_open": session_state.get("project_open", False),
-            "project_name": session_state.get("project_name", "unknown"),
-            "project_path": session_state.get("project_path", "unknown"),
-            "duration": duration,
-            "pipes_exist": pipes_exist,
-            "last_update": last_update_str,
-            "message": "Session information retrieved successfully"
-        }
-    except Exception as e:
-        return {
-            "session_exists": True,
-            "active": False,
-            "error": str(e),
-            "message": f"Error reading session state: {e}"
-        }
+            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session state file not found.")
+            return False
 
-def ping_session():
-    """Attempt to ping the session with a simple command to verify it's responsive"""
-    try:
-        if not os.path.exists(COMMAND_PIPE) or not os.path.exists(RESULT_PIPE):
+        # Read session state
+        try:
+            with open(SESSION_STATE_FILE, 'r') as f:
+                session_state = json.load(f)
+        except json.JSONDecodeError:
+            print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
             return False
-            
-        ping_command = {
-            "id": f"ping_{time.time()}",
-            "type": "execute_script",
-            "script": "print('SCRIPT_SUCCESS: Ping successful')"
-        }
-        
-        # Set a timeout for the ping operation
-        timeout = 5  # seconds
-        
-        # Use non-blocking I/O to handle timeouts
-        import select
-        
-        # Send the ping command
-        with open(COMMAND_PIPE, 'w') as cmd_pipe:
-            cmd_pipe.write(json.dumps(ping_command))
-        
-        # Wait for the result pipe to be readable with timeout
-        res_fd = os.open(RESULT_PIPE, os.O_RDONLY | os.O_NONBLOCK)
-        ready, _, _ = select.select([res_fd], [], [], timeout)
+
+        # Check if session is active
+        active = session_state.get('active', False)
+        status = session_state.get('status', 'unknown')
         
-        if not ready:
-            os.close(res_fd)
+        # If the status indicates the session is not active, return immediately
+        if not active or status in ['stopped', 'error', 'stopping', 'timeout']:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
             return False
-            
-        # Read the result
-        result_json = os.read(res_fd, 4096).decode('utf-8').strip()
-        os.close(res_fd)
         
-        if result_json:
+        # Check session lock file to see if it's been updated recently
+        lock_is_stale = False
+        if os.path.exists(SESSION_LOCK_FILE):
             try:
-                result = json.loads(result_json)
-                return result.get("success", False)
-            except json.JSONDecodeError:
-                return False
+                with open(SESSION_LOCK_FILE, 'r') as f:
+                    lock_time = float(f.read().strip())
+                    current_time = time.time()
+                    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(f"WARNING: Session lock file is stale by {time_diff:.1f} seconds")
+                        lock_is_stale = True
+            except Exception as e:
+                print(f"Error reading lock file: {e}")
+                lock_is_stale = True
         else:
-            return False
-            
-    except Exception as e:
-        print(f"Error pinging session: {e}")
-        return False
-
-def main():
-    try:
-        # Get session status
-        status = check_session_status()
+            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": f"ping_{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(f"Error reading result: {e}")
+                            time.sleep(0.5)
+                    
+                    if not ping_success:
+                        print(f"WARNING: Session did not respond to ping within {timeout} seconds")
+                        
+                        # 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(f"Error resetting command file: {e}")
+                else:
+                    print("WARNING: Command file not found, cannot ping session")
+            except Exception as e:
+                print(f"Error during ping test: {e}")
+                traceback.print_exc()
         
-        # Print status information
-        print(f"Session Exists: {status.get('session_exists', False)}")
-        print(f"Session Active: {status.get('active', False)}")
+        # Make final determination based on all checks
+        session_active = active and (not lock_is_stale or ping_success) and status in ["running", "busy"]
         
-        # If session exists, print more details
-        if status.get("session_exists", False):
-            if status.get("active", False):
-                # Try to ping the session
-                is_responsive = ping_session()
-                print(f"Session Responsive: {is_responsive}")
-                
-                # Print project information if available
-                if "project_open" in status:
-                    print(f"Project Open: {status['project_open']}")
-                if "project_name" in status:
-                    print(f"Project Name: {status['project_name']}")
-                if "project_path" in status:
-                    print(f"Project Path: {status['project_path']}")
-                if "duration" in status:
-                    print(f"Session Duration: {status['duration']}")
-                if "last_update" in status:
-                    print(f"Last Activity: {status['last_update']}")
+        # 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 = f", Project: {project_name} ({project_path})"
+        
+        # Include session info
+        session_id = session_state.get('session_id', 'Unknown')
+        start_time = session_state.get('start_time', 0)
+        uptime = time.time() - start_time if start_time else 0
+        uptime_str = f"{uptime:.0f} seconds" if uptime < 60 else f"{uptime/60:.1f} minutes"
+        
+        if session_active:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is active (ID: {session_id}, Status: {status}, Uptime: {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(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be zombie (ID: {session_id}, Status: {status} but unresponsive)")
+                # 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(f"Error updating session state: {e}")
             else:
-                print("Session is not active (stopped or crashed)")
+                print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
                 
-        # Print the final result marker
-        print(f"{SCRIPT_SUCCESS_MARKER}: Session status check complete")
-        sys.exit(0)
-        
+            return False
+
     except Exception as e:
-        print(f"Error checking session status: {e}")
-        print(f"{SCRIPT_ERROR_MARKER}: {str(e)}")
-        sys.exit(1)
+        print(f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}")
+        traceback.print_exc()
+        return False
 
+# Main script
 if __name__ == "__main__":
-    main()
+    if check_session_status():
+        sys.exit(0)
+    else:
+        sys.exit(1)