@codesys/mcp-toolkit 1.4.7 → 1.4.9

package/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.9] - 2025-05-02
+### Fixed
+- Fixed critical issue with create_project not succeeding in persistent sessions
+- Added comprehensive debugging for project creation operations
+- Improved result file handling to prevent file access issues
+- Enhanced success detection for project file creation when opening fails
+- Fixed issue with result files not being properly written during critical operations
+- Added atomic file writing with fallback mechanisms for result files
+
+## [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

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

@@ -287,8 +287,28 @@ def execute_command(command_data):
                     # For project creation/opening, we'll execute the script with some guards
                     print("Executing critical script with guards...")
                     try:
-                        # Execute the script
+                        # Execute the script in a more controlled manner with debugging
+                        print("DEBUG-CRITICAL: About to execute project creation/open script")
+                        # First write project ops directly to the result file to prevent hanging
+                        try:
+                            with open(RESULT_FILE, 'w') as f:
+                                result_data = {
+                                    "status": "in_progress",
+                                    "result": {
+                                        "id": command.get("id", "unknown"),
+                                        "success": False,
+                                        "output": "Project creation/opening operation in progress...",
+                                    },
+                                    "timestamp": time.time()
+                                }
+                                json.dump(result_data, f, indent=2)
+                            print("DEBUG-CRITICAL: Created preliminary result file")
+                        except Exception as rf_err:
+                            print("DEBUG-CRITICAL: Error creating preliminary result: {0}".format(rf_err))
+                        
+                        # Now execute the script
                         exec(script, local_globals)
+                        print("DEBUG-CRITICAL: Script executed successfully")
                     except Exception as e:
                         # If the script fails, capture the error
                         print("ERROR in critical script execution: {0}".format(e))
@@ -315,6 +335,32 @@ def execute_command(command_data):
                 stdout_output = stdout_buffer.getvalue()
                 stderr_output = stderr_buffer.getvalue()
                 
+                # Special handling for project creation - always check if we can find success markers
+                # in partial output even if script appears to have issues
+                if has_project_create:
+                    # Look specifically for the file copy completion
+                    if "File copy VERIFIED - file exists at destination" in stdout_output or "DEBUG: File copy complete" in stdout_output:
+                        print("IMPORTANT: Detected successful file copy in project creation script")
+                        project_path = ""
+                        
+                        # Try to extract the project path from output
+                        project_path_match = None
+                        for line in stdout_output.split('\n'):
+                            if "DEBUG: Target Path =" in line:
+                                project_path_match = line.split('=')[1].strip()
+                                break
+                        
+                        if project_path_match:
+                            project_path = project_path_match
+                            print("IMPORTANT: Found project path: {0}".format(project_path))
+                            
+                            # Even if there was an error later (like opening), consider this a partial success
+                            if "Error creating project" in stdout_output and "currently in use" in stdout_output:
+                                print("IMPORTANT: Project file was created but couldn't be opened due to 'in use' error")
+                                # Combine success and error markers
+                                stdout_output += "\nSCRIPT_SUCCESS: Project file was created at {0} but could not be opened because it is in use by another CODESYS instance.".format(project_path)
+                                result["success"] = True
+                
                 # Check for success/error markers
                 if SCRIPT_SUCCESS_MARKER in stdout_output or SCRIPT_SUCCESS_MARKER in stderr_output:
                     result["success"] = True
@@ -323,9 +369,18 @@ def execute_command(command_data):
                     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")
+                    # No explicit markers, assume success for non-critical operations
+                    # For critical operations like project creation, be more careful
+                    if has_project_create:
+                        if "File copy complete" in stdout_output:
+                            result["success"] = True
+                            print("Project creation seems successful based on file copy completion")
+                        else:
+                            result["success"] = False
+                            print("Project creation script lacks success markers and file copy confirmation")
+                    else:
+                        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(
@@ -450,7 +505,7 @@ def check_command():
                 result, stop_requested = execute_command(command)
                 print("Command execution complete, stop_requested: {0}".format(stop_requested))
                 
-                # Write the result
+                # Write the result with extra safety measures
                 result_data = {
                     "status": "complete",
                     "result": result,
@@ -458,8 +513,50 @@ def check_command():
                 }
                 
                 print("Writing result to {0}".format(RESULT_FILE))
-                with open(RESULT_FILE, 'w') as f:
-                    json.dump(result_data, f, indent=2)
+                sys.stdout.flush()
+                
+                # First, write to a temporary file to avoid corruption
+                temp_result_file = RESULT_FILE + ".tmp"
+                try:
+                    with open(temp_result_file, 'w') as f:
+                        json.dump(result_data, f, indent=2)
+                    print("Temporary result file written successfully")
+                    
+                    # If temporary write succeeded, move to the real file
+                    if os.path.exists(temp_result_file):
+                        # On Windows, we may need to remove the destination first
+                        if os.path.exists(RESULT_FILE):
+                            try:
+                                os.remove(RESULT_FILE)
+                            except Exception as rm_err:
+                                print("Warning: Could not remove existing result file: {0}".format(rm_err))
+                        
+                        # Now rename the temp file to the real file
+                        os.rename(temp_result_file, RESULT_FILE)
+                        print("Result file updated successfully")
+                    else:
+                        print("ERROR: Temporary result file not found after writing!")
+                        # Try direct write as fallback
+                        with open(RESULT_FILE, 'w') as f:
+                            json.dump(result_data, f, indent=2)
+                except Exception as result_err:
+                    print("ERROR writing result file: {0}".format(result_err))
+                    traceback.print_exc()
+                    sys.stdout.flush()
+                    
+                    # Desperate attempt - try direct write with minimal content
+                    try:
+                        with open(RESULT_FILE, 'w') as f:
+                            f.write('{"status":"complete","result":{"id":"' + 
+                                   result["id"] + '","success":' + 
+                                   ('true' if result["success"] else 'false') + 
+                                   ',"output":"Result writing failed but operation completed"},"timestamp":' + 
+                                   str(time.time()) + '}')
+                        print("Emergency minimal result file written")
+                    except Exception as emergency_err:
+                        print("CRITICAL ERROR: Even emergency result write failed: {0}".format(emergency_err))
+                
+                sys.stdout.flush()
                 
                 # Reset command file
                 command_data = {

package/dist/server.js

@@ -377,9 +377,14 @@ 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) + "...");
                 // Use a longer timeout for project creation operations in sessions (120 seconds)
@@ -427,6 +432,30 @@ function startMcpServer(config) {
                     }
                 }
                 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/package.json

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