@codesys/mcp-toolkit 1.4.5 → 1.4.7

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.7] - 2025-05-02
+### Fixed
+- Fixed create_project freezing in persistent sessions
+- Added special detection and handling for project creation operations
+- Extended timeout for project creation to 120 seconds (from 60 seconds)
+- Added graceful handling of timeouts with partial success detection
+- Improved debugging and monitoring of long-running operations in sessions
+
+## [1.4.6] - 2025-05-02
+### Fixed
+- Fixed session management "hanging" issue with start_session
+- Added stdout flushing in Python scripts to ensure output is visible
+- Improved session script logging for better debugging
+- Added more detailed state information in session scripts
+
 ## [1.4.5] - 2025-05-02
 ### Fixed
 - Completely redesigned path handling for Windows paths

package/dist/scripts/start_session.py

@@ -229,9 +229,34 @@ def execute_command(command_data):
             "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()
@@ -250,17 +275,41 @@ def execute_command(command_data):
                 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
                 
-                try:
-                    # Execute the script
-                    exec(script, local_globals)
-                finally:
-                    # Restore original stdout and stderr
-                    sys.stdout = old_stdout
-                    sys.stderr = old_stderr
+                # 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
+                        exec(script, local_globals)
+                    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()
@@ -269,18 +318,28 @@ def execute_command(command_data):
                 # 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
                     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))
@@ -387,6 +446,7 @@ def check_command():
                 
                 # 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))
                 
@@ -423,6 +483,7 @@ def check_command():
             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:
@@ -448,6 +509,7 @@ def check_command():
     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():
@@ -497,6 +559,7 @@ def command_loop():
     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))
+    sys.stdout.flush()  # Ensure initialization output is visible immediately
     
     # Set up initial session state files
     try:
@@ -519,9 +582,14 @@ def command_loop():
                     "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:
@@ -536,24 +604,27 @@ def command_loop():
             if current_time - last_heartbeat > 60:
                 print("Command loop heartbeat - still alive (iteration {0})".format(loop_count))
                 last_heartbeat = current_time
+                sys.stdout.flush()
             
             # Check for new commands
-            print("Checking for 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()
             
             # Sleep for a bit
             time.sleep(POLL_INTERVAL)
@@ -561,34 +632,48 @@ def command_loop():
         except Exception as e:
             print("Error in command loop: {0}".format(e))
             traceback.print_exc()
+            sys.stdout.flush()
             # 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__":

package/dist/server.js

@@ -66,6 +66,7 @@ const zod_1 = require("zod");
 const codesys_interop_1 = require("./codesys_interop");
 const path = __importStar(require("path"));
 const promises_1 = require("fs/promises");
+const fs = __importStar(require("fs"));
 const scriptLoader_1 = require("./scriptLoader");
 const sessionManager_1 = require("./sessionManager");
 // --- Wrap server logic in an exported function ---
@@ -130,7 +131,7 @@ function startMcpServer(config) {
         console.error("SERVER.TS: Initializing McpServer...");
         const server = new mcp_js_1.McpServer({
             name: "CODESYS Control MCP Server",
-            version: "1.8.0", // Updated version for refactored code
+            version: "1.8.1", // Updated version for session fixes
             capabilities: {
                 resources: { listChanged: true },
                 tools: { listChanged: true }
@@ -381,8 +382,50 @@ function startMcpServer(config) {
                     'TEMPLATE_PROJECT_PATH': normalizedTemplatePath
                 });
                 console.error(">>> create_project (copy-then-open): PREPARED SCRIPT:", scriptContent.substring(0, 500) + "...");
-                const result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName, sessionManager);
+                // Use a longer timeout for project creation operations in sessions (120 seconds)
+                // This helps prevent timing out on slower systems or when CODESYS is busy
+                let result;
+                // Check if we're running in a session
+                if (sessionManager &&
+                    (sessionManager.getState() === sessionManager_1.SessionState.RUNNING ||
+                        sessionManager.getState() === sessionManager_1.SessionState.BUSY)) {
+                    console.error(">>> create_project: Using session with extended timeout (120s)");
+                    try {
+                        // Execute script directly through session manager to specify longer timeout
+                        const scriptResult = yield sessionManager.executeScript(scriptContent, 120000);
+                        result = {
+                            success: scriptResult.success,
+                            output: scriptResult.output
+                        };
+                    }
+                    catch (sessionError) {
+                        console.error(`>>> create_project: Session execution failed, falling back to one-time execution: ${sessionError.message}`);
+                        // Fall back to one-time execution
+                        result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName);
+                    }
+                }
+                else {
+                    // Standard execution without a session
+                    result = yield (0, codesys_interop_1.executeCodesysScript)(scriptContent, codesysExePath, codesysProfileName, sessionManager);
+                }
                 console.error(">>> create_project (copy-then-open): EXECUTION RESULT:", JSON.stringify(result));
+                // Check if there was a timeout but the project might still have been created
+                if (!result.success && result.output.includes("timed out") && result.output.includes("project file might still have been created")) {
+                    console.error(">>> create_project: Script timed out but project might have been created. Checking if file exists.");
+                    // Check if the project file was actually created despite the timeout
+                    const fileExists = fs.existsSync(absPath);
+                    if (fileExists) {
+                        console.error(`>>> create_project: Project file ${absPath} exists despite timeout.`);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Project file was created at ${absPath}, but the operation timed out before completion. ` +
+                                        `The project might be usable, but you may need to manually open it in CODESYS.`
+                                }],
+                            isError: true // Still mark as error because operation didn't complete properly
+                        };
+                    }
+                }
                 const success = result.success && result.output.includes("SCRIPT_SUCCESS");
                 return {
                     content: [{

package/dist/sessionManager.js

@@ -667,9 +667,19 @@ class CodesysSessionManager extends events_1.EventEmitter {
      */
     readResultFile(scriptId) {
         console.error(`SESSION_MANAGER: Starting to read result file for script ${scriptId}`);
+        // Count polling attempts for logging purposes
+        let pollCount = 0;
+        let lastLogTime = Date.now();
         // We'll use a polling approach to read from the file
         const pollInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             try {
+                pollCount++;
+                const now = Date.now();
+                // Log progress every 5 seconds to show we're still working
+                if (now - lastLogTime > 5000) {
+                    console.error(`SESSION_MANAGER: Still polling for result of script ${scriptId}, attempt ${pollCount}`);
+                    lastLogTime = now;
+                }
                 if (!this.pendingScripts.has(scriptId)) {
                     console.error(`SESSION_MANAGER: Script ${scriptId} is no longer pending, stopping poll`);
                     clearInterval(pollInterval);
@@ -677,7 +687,9 @@ class CodesysSessionManager extends events_1.EventEmitter {
                 }
                 // Check if the result file exists
                 if (!fs.existsSync(this.resultFilePath)) {
-                    console.error(`SESSION_MANAGER: Result file not found at ${this.resultFilePath}`);
+                    if (pollCount % 50 === 0) { // Log less frequently
+                        console.error(`SESSION_MANAGER: Result file not found at ${this.resultFilePath} (attempt ${pollCount})`);
+                    }
                     return;
                 }
                 // Read the result file
@@ -689,7 +701,7 @@ class CodesysSessionManager extends events_1.EventEmitter {
                     if (resultData.status === 'complete' && resultData.result) {
                         const result = resultData.result;
                         if (result.id === scriptId) {
-                            console.error(`SESSION_MANAGER: Found result for script ${scriptId}`);
+                            console.error(`SESSION_MANAGER: Found result for script ${scriptId} after ${pollCount} polls`);
                             // Remove from pending scripts
                             if (this.pendingScripts.has(scriptId)) {
                                 const pending = this.pendingScripts.get(scriptId);
@@ -717,9 +729,36 @@ class CodesysSessionManager extends events_1.EventEmitter {
                 console.error(`SESSION_MANAGER: Error reading result file: ${error}`);
             }
         }), 100); // Poll every 100ms
-        // Set a timeout to stop polling after the script timeout
+        // Set a timeout to stop polling and forcibly resolve/reject the script after the script timeout
         setTimeout(() => {
+            console.error(`SESSION_MANAGER: Max polling time reached for script ${scriptId}, cleaning up`);
             clearInterval(pollInterval);
+            // If the script is still pending, force resolve/reject with timeout error
+            if (this.pendingScripts.has(scriptId)) {
+                const pending = this.pendingScripts.get(scriptId);
+                this.pendingScripts.delete(scriptId);
+                // Create a timeout result
+                const timeoutResult = {
+                    id: scriptId,
+                    success: false,
+                    output: `SCRIPT_ERROR: Script execution timed out after reaching maximum polling time. This typically happens when:\n` +
+                        `1. The script is stuck in an infinite loop\n` +
+                        `2. The script has triggered a deadlock in CODESYS\n` +
+                        `3. A CODESYS dialog or error popup is blocking execution\n` +
+                        `4. The project creation or opening is taking too long\n\n` +
+                        `If this is a project creation script, the project file might still have been created successfully.\n` +
+                        `Check the CODESYS UI to see if a project was created and manually close any dialog boxes.`
+                };
+                // Resolve with the timeout result rather than rejecting
+                // This allows the session to continue operating instead of going into error state
+                console.error(`SESSION_MANAGER: Resolving script ${scriptId} with timeout result`);
+                pending.resolve(timeoutResult);
+            }
+            // Check if we need to update session state
+            if (this.pendingScripts.size === 0) {
+                console.error(`SESSION_MANAGER: No more pending scripts, setting state to RUNNING`);
+                this.sessionState = exports.SessionState.RUNNING;
+            }
         }, 60000); // 1 minute max polling time
     }
     /**

package/package.json

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