@codesys/mcp-toolkit 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -5,14 +5,19 @@ 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.1] - 2025-05-02
+### Fixed
+- Fixed IronPython 2.7 compatibility for session management scripts
+- Replaced f-strings with str.format() method calls for IronPython compatibility
+- Added fallback import for json module (using simplejson for IronPython)
+- Improved error handling for session scripts
+- Re-enabled session management feature in codesys_interop.ts
+
 ## [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
+- Implemented initial framework for session management
+- Added foundation for file-based IPC between Node.js and CODESYS instances
+- Created documentation structure for session management capabilities
 
 ## [1.3.0] - 2025-05-02
 ### Changed

package/dist/codesys_interop.js

@@ -92,7 +92,7 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
             throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
         // --- End Pre-checks ---
         // Enable or disable session management
-        const SESSION_FEATURE_DISABLED = false;
+        const SESSION_FEATURE_DISABLED = false; // Session feature enabled
         // --- Check if we should use the persistent session ---
         if (!SESSION_FEATURE_DISABLED && sessionManager) {
             const sessionState = sessionManager.getState();

package/dist/scripts/session_status.py

@@ -1,6 +1,13 @@
-import sys, os, json, time, traceback
+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
+    import simplejson as json
+
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -17,12 +24,12 @@ def check_session_status():
     try:
         # Check if session directory exists
         if not os.path.exists(SESSION_DIR):
-            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session directory not found.")
+            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(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session state file not found.")
+            print("{0}: No session active. Session state file not found.".format(SCRIPT_SUCCESS_MARKER))
             return False
 
         # Read session state
@@ -30,7 +37,7 @@ def check_session_status():
             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")
+            print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
             return False
 
         # Check if session is active
@@ -39,7 +46,7 @@ def check_session_status():
         
         # 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})")
+            print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
             return False
         
         # Check session lock file to see if it's been updated recently
@@ -53,10 +60,10 @@ def check_session_status():
                     
                     # 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")
+                        print("WARNING: Session lock file is stale by {0:.1f} seconds".format(time_diff))
                         lock_is_stale = True
             except Exception as e:
-                print(f"Error reading lock file: {e}")
+                print("Error reading lock file: {0}".format(e))
                 lock_is_stale = True
         else:
             print("WARNING: Session lock file not found")
@@ -74,7 +81,7 @@ def check_session_status():
                     
                     # Create ping command
                     ping_command = {
-                        "id": f"ping_{int(time.time())}",
+                        "id": "ping_{0}".format(int(time.time())),
                         "type": "ping",  # Use specific ping command type
                         "timestamp": time.time()
                     }
@@ -110,11 +117,11 @@ def check_session_status():
                                         print("Ping successful, session is responsive")
                                         break
                         except Exception as e:
-                            print(f"Error reading result: {e}")
+                            print("Error reading result: {0}".format(e))
                             time.sleep(0.5)
                     
                     if not ping_success:
-                        print(f"WARNING: Session did not respond to ping within {timeout} seconds")
+                        print("WARNING: Session did not respond to ping within {0} seconds".format(timeout))
                         
                         # Reset command file since ping failed
                         try:
@@ -129,11 +136,11 @@ def check_session_status():
                                 
                             print("Reset command file after failed ping")
                         except Exception as e:
-                            print(f"Error resetting command file: {e}")
+                            print("Error resetting command file: {0}".format(e))
                 else:
                     print("WARNING: Command file not found, cannot ping session")
             except Exception as e:
-                print(f"Error during ping test: {e}")
+                print("Error during ping test: {0}".format(e))
                 traceback.print_exc()
         
         # Make final determination based on all checks
@@ -144,21 +151,21 @@ def check_session_status():
         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})"
+            project_info = ", Project: {0} ({1})".format(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"
+        uptime_str = "{0:.0f} seconds".format(uptime) if uptime < 60 else "{0:.1f} minutes".format(uptime/60)
         
         if session_active:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is active (ID: {session_id}, Status: {status}, Uptime: {uptime_str}{project_info})")
+            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(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be zombie (ID: {session_id}, Status: {status} but unresponsive)")
+                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'
@@ -170,14 +177,14 @@ def check_session_status():
                         
                     print("Updated session state to error due to unresponsiveness")
                 except Exception as e:
-                    print(f"Error updating session state: {e}")
+                    print("Error updating session state: {0}".format(e))
             else:
-                print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
+                print("{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status))
                 
             return False
 
     except Exception as e:
-        print(f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}")
+        print("{0}: Error checking session status - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
         traceback.print_exc()
         return False
 

package/dist/scripts/start_session.py

@@ -1,5 +1,19 @@
-import sys, os, json, time, tempfile, traceback
-import scriptengine as script_engine
+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
+    import simplejson as json
+    
+# Import scriptengine
+try:
+    import scriptengine as script_engine
+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
 
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
@@ -25,7 +39,7 @@ def setup_session_dir():
                     try:
                         with open(SESSION_STATE_FILE, 'r') as f:
                             old_state = json.load(f)
-                            print(f"Cleaning up previous session (ID: {old_state.get('session_id', 'unknown')})")
+                            print("Cleaning up previous session (ID: {0})".format(old_state.get('session_id', 'unknown')))
                     except:
                         pass
                 
@@ -36,9 +50,9 @@ def setup_session_dir():
                         if os.path.isfile(filepath):
                             os.unlink(filepath)
                     except Exception as e:
-                        print(f"Error removing file {filepath}: {e}")
+                        print("Error removing file {0}: {1}".format(filepath, e))
             except Exception as e:
-                print(f"Error cleaning up previous session: {e}")
+                print("Error cleaning up previous session: {0}".format(e))
         
         # Create session directory
         if not os.path.exists(SESSION_DIR):
@@ -74,12 +88,12 @@ def setup_session_dir():
         with open(SESSION_LOCK_FILE, 'w') as f:
             f.write(str(time.time()))
         
-        print(f"Session directory setup at: {SESSION_DIR}")
-        print(f"Session ID: {session_id}")
+        print("Session directory setup at: {0}".format(SESSION_DIR))
+        print("Session ID: {0}".format(session_id))
         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)}")
+        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"):
@@ -90,20 +104,29 @@ def update_session_state(status="running"):
         project_name = "No project open"
         project_path = "N/A"
         
-        primary_project = script_engine.projects.primary
-        if primary_project:
-            project_open = True
+        # 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:
-                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)"
+                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:
@@ -133,7 +156,7 @@ def update_session_state(status="running"):
             
         return True
     except Exception as e:
-        print(f"Failed to update session state: {e}")
+        print("Failed to update session state: {0}".format(e))
         traceback.print_exc()
         return False
 
@@ -189,13 +212,13 @@ def execute_command(command_data):
             except Exception as e:
                 traceback.print_exc()
                 result["success"] = False
-                result["error"] = f"Error executing script: {str(e)}\n{traceback.format_exc()}"
-                result["output"] = f"{SCRIPT_ERROR_MARKER}: {str(e)}"
+                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"] = f"{SCRIPT_SUCCESS_MARKER}: Session stopping"
+            result["output"] = "{0}: Session stopping".format(SCRIPT_SUCCESS_MARKER)
             
             # Update session state to mark as stopping
             update_session_state("stopping")
@@ -206,12 +229,12 @@ def execute_command(command_data):
         elif cmd_type == "ping":
             # Simple ping command to check if session is alive
             result["success"] = True
-            result["output"] = f"{SCRIPT_SUCCESS_MARKER}: Session is active"
+            result["output"] = "{0}: Session is active".format(SCRIPT_SUCCESS_MARKER)
         
         else:
             result["success"] = False
-            result["error"] = f"Unknown command type: {cmd_type}"
-            result["output"] = f"{SCRIPT_ERROR_MARKER}: Unknown command type: {cmd_type}"
+            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()
@@ -223,8 +246,8 @@ def execute_command(command_data):
         return {
             "id": command_data.get("id", "unknown"),
             "success": False,
-            "output": f"{SCRIPT_ERROR_MARKER}: Command execution failed",
-            "error": f"{str(e)}\n{traceback.format_exc()}"
+            "output": "{0}: Command execution failed".format(SCRIPT_ERROR_MARKER),
+            "error": "{0}\n{1}".format(str(e), traceback.format_exc())
         }, False
 
 def check_command():
@@ -292,7 +315,7 @@ def check_command():
         
         return False
     except Exception as e:
-        print(f"Error checking command: {e}")
+        print("Error checking command: {0}".format(e))
         traceback.print_exc()
         return False
 
@@ -308,7 +331,7 @@ def update_last_activity():
             with open(SESSION_STATE_FILE, 'w') as f:
                 json.dump(state, f, indent=2)
     except Exception as e:
-        print(f"Error updating last activity: {e}")
+        print("Error updating last activity: {0}".format(e))
 
 def check_inactivity_timeout():
     """Check if session has been inactive for too long"""
@@ -321,12 +344,12 @@ def check_inactivity_timeout():
             current_time = time.time()
             
             if (current_time - last_activity) > MAX_INACTIVITY_TIME:
-                print(f"Session inactive for {current_time - last_activity:.1f} seconds, shutting down")
+                print("Session inactive for {0:.1f} seconds, shutting down".format(current_time - last_activity))
                 return True
         
         return False
     except Exception as e:
-        print(f"Error checking inactivity timeout: {e}")
+        print("Error checking inactivity timeout: {0}".format(e))
         return False
 
 def command_loop():
@@ -334,9 +357,9 @@ def command_loop():
     stop_requested = False
     last_state_update = time.time()
     
-    print(f"Starting command loop...")
-    print(f"Command file: {COMMAND_FILE}")
-    print(f"Result file: {RESULT_FILE}")
+    print("Starting command loop...")
+    print("Command file: {0}".format(COMMAND_FILE))
+    print("Result file: {0}".format(RESULT_FILE))
     
     while not stop_requested:
         try:
@@ -363,7 +386,7 @@ def command_loop():
             time.sleep(POLL_INTERVAL)
         
         except Exception as e:
-            print(f"Error in command loop: {e}")
+            print("Error in command loop: {0}".format(e))
             traceback.print_exc()
             # Sleep for a bit
             time.sleep(POLL_INTERVAL)
@@ -381,17 +404,17 @@ def main():
         update_session_state()
         
         # Start command loop
-        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session started")
+        print("{0}: CODESYS session started".format(SCRIPT_SUCCESS_MARKER))
         command_loop()
         
         # Update final state
         update_session_state("stopped")
         
-        print(f"{SCRIPT_SUCCESS_MARKER}: CODESYS session stopped cleanly")
+        print("{0}: CODESYS session stopped cleanly".format(SCRIPT_SUCCESS_MARKER))
         sys.exit(0)
     except Exception as e:
-        print(f"Error in session: {e}")
-        print(f"{SCRIPT_ERROR_MARKER}: Session failed - {str(e)}")
+        print("Error in session: {0}".format(e))
+        print("{0}: Session failed - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
         traceback.print_exc()
         sys.exit(1)
 

package/dist/scripts/stop_session.py

@@ -1,6 +1,13 @@
-import sys, os, json, time, traceback
+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
+    import simplejson as json
+
 # Define markers for script results
 SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
 SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
@@ -17,12 +24,12 @@ def stop_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}")
+            print("{0}: No session directory found at {1}".format(SCRIPT_ERROR_MARKER, 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}")
+            print("{0}: No session state file found at {1}".format(SCRIPT_ERROR_MARKER, SESSION_STATE_FILE))
             return False
 
         # Read session state
@@ -30,17 +37,17 @@ def stop_session():
             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")
+            print("{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER))
             return False
 
         # Check if session is active
         if not session_state.get('active', False) or session_state.get('status') == 'stopped':
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session is already stopped")
+            print("{0}: Session is already stopped".format(SCRIPT_SUCCESS_MARKER))
             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}")
+            print("{0}: Command file not found at {1}".format(SCRIPT_ERROR_MARKER, COMMAND_FILE))
             return False
 
         # Try to read the lock file to check if session is still alive
@@ -52,13 +59,13 @@ def stop_session():
                     
                 current_time = time.time()
                 if (current_time - lock_time) > 30:
-                    print(f"WARNING: Session lock file is stale ({current_time - lock_time:.1f} seconds old). Session may have crashed.")
+                    print("WARNING: Session lock file is stale ({0:.1f} seconds old). Session may have crashed.".format(current_time - lock_time))
         except Exception as e:
-            print(f"Warning: Error reading lock file: {e}")
+            print("Warning: Error reading lock file: {0}".format(e))
 
         # Create stop command
         stop_command = {
-            "id": f"stop_{int(time.time())}",
+            "id": "stop_{0}".format(int(time.time())),
             "type": "stop",
             "timestamp": time.time()
         }
@@ -73,7 +80,7 @@ def stop_session():
         with open(COMMAND_FILE, 'w') as f:
             json.dump(command_data, f, indent=2)
 
-        print(f"Stop command sent to session")
+        print("Stop command sent to session")
 
         # Wait for result (with timeout)
         timeout = 15  # seconds (increased timeout for more reliability)
@@ -94,10 +101,10 @@ def stop_session():
                         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')}")
+                            print("Session stop result: {0}".format(result.get('output', 'No output')))
                             break
             except Exception as e:
-                print(f"Error reading result: {e}")
+                print("Error reading result: {0}".format(e))
                 time.sleep(0.5)
 
         # Update session state to indicate it's stopped regardless of result
@@ -112,15 +119,15 @@ def stop_session():
             with open(SESSION_STATE_FILE, 'w') as f:
                 json.dump(session_state, f, indent=2)
         except Exception as e:
-            print(f"Warning: Failed to update session state file: {e}")
+            print("Warning: Failed to update session state file: {0}".format(e))
 
         if result_received:
-            print(f"{SCRIPT_SUCCESS_MARKER}: Session stopped successfully")
+            print("{0}: Session stopped successfully".format(SCRIPT_SUCCESS_MARKER))
             return True
         else:
             # If we didn't get a response, the session may be hung
             # Force a cleanup by removing session files
-            print(f"Warning: Session did not respond to stop command. Forcing cleanup.")
+            print("Warning: Session did not respond to stop command. Forcing cleanup.")
             try:
                 # Try to remove all session files to ensure a clean state for next session
                 for filename in os.listdir(SESSION_DIR):
@@ -129,16 +136,16 @@ def stop_session():
                         if os.path.isfile(filepath):
                             os.unlink(filepath)
                     except Exception as e:
-                        print(f"Error removing file {filepath}: {e}")
+                        print("Error removing file {0}: {1}".format(filepath, e))
                 
-                print(f"{SCRIPT_SUCCESS_MARKER}: Session files cleaned up forcefully")
+                print("{0}: Session files cleaned up forcefully".format(SCRIPT_SUCCESS_MARKER))
                 return True
             except Exception as e:
-                print(f"{SCRIPT_ERROR_MARKER}: Failed to force cleanup - {str(e)}")
+                print("{0}: Failed to force cleanup - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
                 return False
 
     except Exception as e:
-        print(f"{SCRIPT_ERROR_MARKER}: Error stopping session - {str(e)}")
+        print("{0}: Error stopping session - {1}".format(SCRIPT_ERROR_MARKER, str(e)))
         traceback.print_exc()
         return False
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codesys/mcp-toolkit",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Model Context Protocol (MCP) server for CODESYS automation platform",
   "main": "dist/server.js",
   "bin": {

package/replacements_session_status.txt

@@ -0,0 +1,16 @@
+f"{SCRIPT_ERROR_MARKER}: Invalid session state file" | "{0}: Invalid session state file".format(SCRIPT_ERROR_MARKER)
+f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})" | "{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status)
+f"WARNING: Session lock file is stale by {time_diff:.1f} seconds" | "WARNING: Session lock file is stale by {0:.1f} seconds".format(time_diff)
+f"Error reading lock file: {e}" | "Error reading result: {0}".format(e)
+f"ping_{int(time.time())}" | "ping_{0}".format(int(time.time()))
+f"WARNING: Session did not respond to ping within {timeout} seconds" | "WARNING: Session did not respond to ping within {0} seconds".format(timeout)
+f"Error resetting command file: {e}" | "Error resetting command file: {0}".format(e)
+f"Error during ping test: {e}" | "Error during ping test: {0}".format(e)
+f", Project: {project_name} ({project_path})" | ", Project: {0} ({1})".format(project_name, project_path)
+f"{uptime:.0f} seconds" | "{0:.0f} seconds".format(uptime)
+f"{uptime/60:.1f} minutes" | "{0:.1f} minutes".format(uptime/60)
+f"{SCRIPT_SUCCESS_MARKER}: Session is active (ID: {session_id}, Status: {status}, Uptime: {uptime_str}{project_info})" | "{0}: Session is active (ID: {1}, Status: {2}, Uptime: {3}{4})".format(SCRIPT_SUCCESS_MARKER, session_id, status, uptime_str, project_info)
+f"{SCRIPT_SUCCESS_MARKER}: Session appears to be zombie (ID: {session_id}, Status: {status} but unresponsive)" | "{0}: Session appears to be zombie (ID: {1}, Status: {2} but unresponsive)".format(SCRIPT_SUCCESS_MARKER, session_id, status)
+f"Error updating session state: {e}" | "Error updating session state: {0}".format(e)
+f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})" | "{0}: Session is not active (Status: {1})".format(SCRIPT_SUCCESS_MARKER, status)
+f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}" | "{0}: Error checking session status - {1}".format(SCRIPT_ERROR_MARKER, str(e))

package/scripts/fix_fstrings.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Script to fix f-strings in Python files to make them compatible with IronPython 2.7.
+Converts f-strings to str.format() calls.
+"""
+
+import re
+import sys
+import os
+
+def process_file(filepath):
+    print(f"Processing {filepath}")
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Find and replace f-strings
+    # This is a simplified approach - complex nested expressions might need manual review
+    pattern = r'f"([^"]*\{[^}]+\}[^"]*)"'
+    
+    # Count potential matches
+    matches = re.findall(pattern, content)
+    print(f"Found {len(matches)} potential f-strings")
+    
+    # Function to convert each match
+    def replace_fstring(match):
+        template_str = match.group(1)
+        # Replace {var} with {0}, {1}, etc.
+        var_pattern = r'\{([^}:]+)(?::([^}]+))?\}'
+        var_matches = re.finditer(var_pattern, template_str)
+        
+        format_args = []
+        i = 0
+        
+        new_template = template_str
+        for m in var_matches:
+            var_name = m.group(1)
+            format_spec = m.group(2)
+            
+            if format_spec:
+                repl = "{" + str(i) + ":" + format_spec + "}"
+            else:
+                repl = "{" + str(i) + "}"
+                
+            # Store the argument
+            format_args.append(var_name)
+            
+            # Replace in the template
+            new_template = new_template.replace(m.group(0), repl, 1)
+            i += 1
+            
+        # Build the complete format expression
+        args_str = ", ".join(format_args)
+        return f'"{new_template}".format({args_str})'
+    
+    # Apply the replacements
+    new_content = re.sub(pattern, replace_fstring, content)
+    
+    # Write the changes back
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(new_content)
+    
+    print(f"Completed processing {filepath}")
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python fix_fstrings.py <file_paths...>")
+        sys.exit(1)
+    
+    for file_path in sys.argv[1:]:
+        if os.path.exists(file_path):
+            process_file(file_path)
+        else:
+            print(f"Error: File {file_path} not found")
+
+if __name__ == "__main__":
+    main()