@codesys/mcp-toolkit 1.4.6 → 1.4.8

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.8] - 2025-05-02
+### Fixed
+- Fixed critical bug with project creation in persistent sessions
+- Added SKIP_OPEN option to create_project script for session compatibility
+- Improved handling of project creation in sessions to avoid "project in use" errors
+- Added better error recovery when project file exists but can't be opened in a session
+- Added helpful user messages explaining session limitations with project operations
+
+## [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

package/dist/scripts/create_project.py

@@ -4,6 +4,8 @@ import sys, scriptengine as script_engine, os, shutil, time, traceback
 # Paths will be correctly escaped in the template substitution
 TEMPLATE_PROJECT_PATH = '{TEMPLATE_PROJECT_PATH}' 
 PROJECT_FILE_PATH = '{PROJECT_FILE_PATH}'
+# Optional flag to skip opening the project after creation (useful for sessions)
+SKIP_OPEN = '{SKIP_OPEN}' == 'true'
 
 # Print raw paths for debugging
 print("DEBUG: Template path (raw): %s" % repr(TEMPLATE_PROJECT_PATH))
@@ -61,6 +63,13 @@ try:
         
     print("DEBUG: File copy complete.")
 
+    # For sessions, we may want to skip opening the project to avoid conflicts
+    if SKIP_OPEN:
+        print("DEBUG: SKIP_OPEN is set to true, skipping project open step.")
+        print("Project Created from Template Copy at: %s" % PROJECT_FILE_PATH)
+        print("SCRIPT_SUCCESS: Project copied from template (open step skipped for session compatibility).")
+        sys.exit(0)
+    
     # 2. Open the newly copied project file
     print("DEBUG: Opening the copied project: %s" % PROJECT_FILE_PATH)
     # Set flags for silent opening
@@ -71,24 +80,31 @@ try:
     #     print("WARN: VersionUpdateFlags not found, using integer flags for open (1 | 2 = 3).")
     #     update_mode = 3
 
-    project = script_engine.projects.open(PROJECT_FILE_PATH, update_flags=update_mode)
-    print("DEBUG: script_engine.projects.open returned: %s" % project)
-    if project:
-        print("DEBUG: Pausing briefly after open...")
-        time.sleep(1.0) # Allow CODESYS to potentially initialize things
-        try:
-            print("DEBUG: Explicitly saving project after opening copy...")
-            project.save();
-            print("DEBUG: Project save after opening copy succeeded.")
-        except Exception as save_err:
-             print("WARN: Explicit save after opening copy failed: %s" % save_err)
-             # Decide if this is critical - maybe not, but good to know.
-        print("Project Created from Template Copy at: %s" % PROJECT_FILE_PATH)
-        print("SCRIPT_SUCCESS: Project copied from template and opened successfully.")
+    try:
+        project = script_engine.projects.open(PROJECT_FILE_PATH, update_flags=update_mode)
+        print("DEBUG: script_engine.projects.open returned: %s" % project)
+        if project:
+            print("DEBUG: Pausing briefly after open...")
+            time.sleep(1.0) # Allow CODESYS to potentially initialize things
+            try:
+                print("DEBUG: Explicitly saving project after opening copy...")
+                project.save();
+                print("DEBUG: Project save after opening copy succeeded.")
+            except Exception as save_err:
+                print("WARN: Explicit save after opening copy failed: %s" % save_err)
+                # Decide if this is critical - maybe not, but good to know.
+            print("Project Created from Template Copy at: %s" % PROJECT_FILE_PATH)
+            print("SCRIPT_SUCCESS: Project copied from template and opened successfully.")
+            sys.exit(0)
+        else:
+            error_message = "Failed to open project copy %s after copying template %s. projects.open returned None." % (PROJECT_FILE_PATH, TEMPLATE_PROJECT_PATH)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+    except Exception as open_err:
+        print("WARN: Error opening project after creation: %s" % open_err)
+        # Even though we couldn't open it, the project was still created successfully
+        print("Project Created from Template Copy at: %s (but could not be opened automatically)" % PROJECT_FILE_PATH)
+        print("SCRIPT_SUCCESS: Project copied from template (but open operation failed: %s)." % open_err)
         sys.exit(0)
-    else:
-        error_message = "Failed to open project copy %s after copying template %s. projects.open returned None." % (PROJECT_FILE_PATH, TEMPLATE_PROJECT_PATH)
-        print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
 except Exception as e:
     detailed_error = traceback.format_exc()
     error_message = "Error creating project '%s' from template '%s': %s\\n%s" % (PROJECT_FILE_PATH, TEMPLATE_PROJECT_PATH, e, detailed_error)

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))

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 ---
@@ -376,14 +377,85 @@ function startMcpServer(config) {
                 const normalizedTargetPath = absPath.replace(/\\/g, '/');
                 const normalizedTemplatePath = templatePath.replace(/\\/g, '/');
                 console.error(`Using normalized paths for script: Target=${normalizedTargetPath}, Template=${normalizedTemplatePath}`);
+                // When running in a session, skip the open step to avoid conflicts
+                const inSession = sessionManager &&
+                    (sessionManager.getState() === sessionManager_1.SessionState.RUNNING ||
+                        sessionManager.getState() === sessionManager_1.SessionState.BUSY);
                 const scriptContent = (0, scriptLoader_1.interpolateScript)(scriptTemplate, {
                     'PROJECT_FILE_PATH': normalizedTargetPath,
-                    'TEMPLATE_PROJECT_PATH': normalizedTemplatePath
+                    'TEMPLATE_PROJECT_PATH': normalizedTemplatePath,
+                    'SKIP_OPEN': inSession ? 'true' : 'false'
                 });
                 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");
+                // Special handling for cases where project was created but couldn't be opened automatically
+                if (success && inSession && result.output.includes("open operation failed")) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Project created from template: ${absPath}\n` +
+                                    `Note: The project was created successfully, but couldn't be opened automatically because you're in a session.\n` +
+                                    `You can use open_project to open it now, or create a POU directly with create_pou.`
+                            }],
+                        isError: false
+                    };
+                }
+                // Special handling for skipped open operations in sessions
+                if (success && inSession && result.output.includes("open step skipped for session compatibility")) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Project created from template: ${absPath}\n` +
+                                    `Note: The project opening step was skipped because you're in a session.\n` +
+                                    `You can use open_project to open it now, or create a POU directly with create_pou.`
+                            }],
+                        isError: false
+                    };
+                }
                 return {
                     content: [{
                             type: "text",

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.6",
+  "version": "1.4.8",
   "description": "Model Context Protocol (MCP) server for CODESYS automation platform",
   "main": "dist/server.js",
   "bin": {