@codesys/mcp-toolkit 1.2.0 → 1.2.4

package/.claude/settings.local.json

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

package/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.2.4] - 2025-05-02 
+### Fixed
+- Fully disabled session management to prevent operations appearing to succeed but not actually running
+- Made it clearer that the persistent session feature is not yet implemented
+
+## [1.2.3] - 2025-05-02
+### Fixed
+- Improved Windows path handling in Python scripts
+- Added better error detection and reporting for file operations
+- Enhanced debugging for file creation operations
+
+## [1.2.2] - 2025-05-02
+### Fixed
+- Fixed issue where session management appeared to work but didn't create files
+- Temporarily disabled incomplete session manager implementation
+
+## [1.2.1] - 2025-05-02
+### Fixed
+- Fixed Python script templates not being included in the npm package
+
 ## [1.2.0] - 2025-05-02
 ### Added
 - Session management functionality with `start_session`, `stop_session`, and `session_status` commands

package/dist/codesys_interop.js

@@ -56,12 +56,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeCodesysScript = executeCodesysScript;
+exports.checkSessionStatus = checkSessionStatus;
+exports.startSession = startSession;
+exports.stopSession = stopSession;
 const child_process_1 = require("child_process");
 const promises_1 = require("fs/promises");
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const fs = __importStar(require("fs")); // Import fs for existsSync check
-// Optional import for session manager
+// Session manager import
 const sessionManager_1 = require("./sessionManager");
 // Define expected success/error markers from the Python scripts
 const SCRIPT_SUCCESS_MARKER = 'SCRIPT_SUCCESS';
@@ -88,12 +91,16 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
         if (!fs.existsSync(codesysExePath))
             throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
         // --- End Pre-checks ---
+        // Enable or disable session management
+        const SESSION_FEATURE_DISABLED = false;
         // --- Check if we should use the persistent session ---
-        if (sessionManager) {
+        if (!SESSION_FEATURE_DISABLED && sessionManager) {
             const sessionState = sessionManager.getState();
+            // Check if the session is active
             if (sessionState === sessionManager_1.SessionState.RUNNING || sessionState === sessionManager_1.SessionState.BUSY) {
                 process.stderr.write(`INTEROP: Using persistent session for script execution\n`);
                 try {
+                    // Execute the script in the session
                     const result = yield sessionManager.executeScript(scriptContent);
                     return {
                         success: result.success,
@@ -106,10 +113,40 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
                     // Continue with the non-persistent approach as fallback
                 }
             }
+            else if (sessionState === sessionManager_1.SessionState.STOPPED || sessionState === sessionManager_1.SessionState.ERROR) {
+                // Try to start the session if it's stopped or in error state
+                process.stderr.write(`INTEROP: Session is in ${sessionState} state. Attempting to start it.\n`);
+                try {
+                    yield sessionManager.startSession();
+                    const newState = sessionManager.getState();
+                    if (newState === sessionManager_1.SessionState.RUNNING) {
+                        process.stderr.write(`INTEROP: Session started successfully. Using it for script execution.\n`);
+                        // Now that the session is running, execute the script
+                        const result = yield sessionManager.executeScript(scriptContent);
+                        return {
+                            success: result.success,
+                            output: result.output
+                        };
+                    }
+                    else {
+                        process.stderr.write(`INTEROP: Failed to start session (state: ${newState}). Using one-time execution.\n`);
+                    }
+                }
+                catch (error) {
+                    process.stderr.write(`INTEROP: Error starting session: ${error.message}\n`);
+                    process.stderr.write(`INTEROP: Using one-time execution as fallback.\n`);
+                }
+            }
             else {
                 process.stderr.write(`INTEROP: Session not in RUNNING/BUSY state (current: ${sessionState}). Using one-time execution.\n`);
             }
         }
+        else if (SESSION_FEATURE_DISABLED) {
+            process.stderr.write(`INTEROP: Session feature is disabled. Using one-time execution mode.\n`);
+        }
+        else {
+            process.stderr.write(`INTEROP: No session manager provided. Using one-time execution mode.\n`);
+        }
         // --- Standard one-time script execution ---
         const tempDir = os.tmpdir();
         const tempFileName = `codesys_script_${Date.now()}_${Math.random().toString(36).substring(2, 9)}.py`;
@@ -295,3 +332,107 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
         return { success, output: finalOutput };
     });
 }
+/**
+ * Checks if a session is currently active
+ *
+ * @param codesysExePath The full path to the CODESYS.exe executable
+ * @param codesysProfileName The name of the CODESYS profile to use for scripting
+ * @param sessionManager The session manager instance
+ * @returns Promise resolving to an object with session status
+ */
+function checkSessionStatus(codesysExePath, codesysProfileName, sessionManager) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!sessionManager) {
+            return { active: false, info: null };
+        }
+        try {
+            // Check if session is active
+            const isActive = yield sessionManager.isSessionActive();
+            if (!isActive) {
+                return { active: false, info: null };
+            }
+            // Get session information
+            const sessionInfo = yield sessionManager.getSessionInfo();
+            return {
+                active: true,
+                info: sessionInfo
+            };
+        }
+        catch (error) {
+            process.stderr.write(`INTEROP: Error checking session status: ${error.message}\n`);
+            return { active: false, info: null };
+        }
+    });
+}
+/**
+ * Starts a new persistent CODESYS session
+ *
+ * @param codesysExePath The full path to the CODESYS.exe executable
+ * @param codesysProfileName The name of the CODESYS profile to use for scripting
+ * @param sessionManager The session manager instance
+ * @returns Promise resolving when the session has started
+ */
+function startSession(codesysExePath, codesysProfileName, sessionManager) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!sessionManager) {
+            return { success: false, message: "No session manager provided" };
+        }
+        try {
+            // Check if session is already active
+            const isActive = yield sessionManager.isSessionActive();
+            if (isActive) {
+                return { success: true, message: "Session is already active" };
+            }
+            // Start a new session
+            yield sessionManager.startSession();
+            // Check if session started successfully
+            const statusAfterStart = yield sessionManager.isSessionActive();
+            if (statusAfterStart) {
+                return { success: true, message: "Session started successfully" };
+            }
+            else {
+                return { success: false, message: "Failed to start session" };
+            }
+        }
+        catch (error) {
+            process.stderr.write(`INTEROP: Error starting session: ${error.message}\n`);
+            return { success: false, message: `Error starting session: ${error.message}` };
+        }
+    });
+}
+/**
+ * Stops an active CODESYS session
+ *
+ * @param codesysExePath The full path to the CODESYS.exe executable
+ * @param codesysProfileName The name of the CODESYS profile to use for scripting
+ * @param sessionManager The session manager instance
+ * @returns Promise resolving when the session has stopped
+ */
+function stopSession(codesysExePath, codesysProfileName, sessionManager) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!sessionManager) {
+            return { success: false, message: "No session manager provided" };
+        }
+        try {
+            // Check if session is active
+            const isActive = yield sessionManager.isSessionActive();
+            if (!isActive) {
+                return { success: true, message: "No active session to stop" };
+            }
+            // Stop the session
+            yield sessionManager.stopSession();
+            // Verify session stopped
+            const statusAfterStop = yield sessionManager.isSessionActive();
+            if (!statusAfterStop) {
+                return { success: true, message: "Session stopped successfully" };
+            }
+            else {
+                return { success: false, message: "Failed to stop session" };
+            }
+        }
+        catch (error) {
+            process.stderr.write(`INTEROP: Error stopping session: ${error.message}\n`);
+            return { success: false, message: `Error stopping session: ${error.message}` };
+        }
+    });
+}

package/dist/scriptLoader.js

@@ -121,8 +121,20 @@ function interpolateScript(template, params) {
     let result = template;
     // Replace each parameter in the template
     for (const [key, value] of Object.entries(params)) {
-        // Convert value to string and escape backslashes for Python
-        const escapedValue = String(value).replace(/\\/g, '\\\\');
+        // Handle Windows paths specially
+        let escapedValue;
+        // Check if this looks like a Windows path
+        if (typeof value === 'string' && (value.includes(':\\') || value.includes('\\'))) {
+            // For Windows paths, use a different approach with raw strings
+            console.error(`SCRIPT_LOADER: Detected Windows path: ${value}`);
+            // Use Python raw string format to avoid backslash interpretation issues
+            escapedValue = `r'${value.replace(/'/g, "\\'")}'`;
+            console.error(`SCRIPT_LOADER: Converted to Python raw string: ${escapedValue}`);
+        }
+        else {
+            // For non-path values, just escape backslashes normally
+            escapedValue = String(value).replace(/\\/g, '\\\\');
+        }
         // Replace {PARAM_NAME} with the escaped value
         const paramPattern = new RegExp(`\\{${key}\\}`, 'g');
         result = result.replace(paramPattern, escapedValue);

package/dist/scripts/check_status.py

@@ -0,0 +1,21 @@
+import sys, scriptengine as script_engine, os, traceback
+project_open = False; project_name = "No project open"; project_path = "N/A"; scripting_ok = False
+try:
+    scripting_ok = True; 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() # Might fail
+                 if not project_name: project_name = "Unnamed (path: %s)" % os.path.basename(project_path)
+            except: project_name = "Unnamed (path: %s)" % os.path.basename(project_path)
+        except Exception as e_path: project_path = "N/A (Error: %s)" % e_path; project_name = "Unnamed (Path Error)"
+    print("Project Open: %s" % project_open); print("Project Name: %s" % project_name)
+    print("Project Path: %s" % project_path); print("Scripting OK: %s" % scripting_ok)
+    print("SCRIPT_SUCCESS: Status check complete."); sys.exit(0)
+except Exception as e:
+    error_message = "Error during status check: %s" % e
+    print(error_message); print("Scripting OK: False")
+    # traceback.print_exc() # Optional traceback
+    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/compile_project.py

@@ -0,0 +1,65 @@
+import sys, scriptengine as script_engine, os, traceback
+
+# Import ensure_project_open function from the template
+# This will be prepended by the script loader
+def ensure_project_open(target_project_path):
+    # Function implementation will be included from ensure_project_open.py
+    pass
+
+try:
+    print("DEBUG: compile_project script: Project='%s'" % PROJECT_FILE_PATH)
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    project_name = os.path.basename(PROJECT_FILE_PATH)
+    target_app = None
+    app_name = "N/A"
+
+    # Try getting active application first
+    try:
+        target_app = primary_project.active_application
+        if target_app:
+            app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (Active)")()
+            print("DEBUG: Found active application: %s" % app_name)
+    except Exception as active_err:
+        print("WARN: Could not get active application: %s. Searching..." % active_err)
+
+    # If no active app, search for the first one
+    if not target_app:
+        print("DEBUG: Searching for first compilable application...")
+        apps = []
+        try:
+             # Search recursively through all project objects
+             all_children = primary_project.get_children(True)
+             for child in all_children:
+                  # Check using the marker property and if build method exists
+                  if hasattr(child, 'is_application') and child.is_application and hasattr(child, 'build'):
+                       app_name_found = getattr(child, 'get_name', lambda: "Unnamed App")()
+                       print("DEBUG: Found potential application object: %s" % app_name_found)
+                       apps.append(child)
+                       break # Take the first one found
+        except Exception as find_err: print("WARN: Error finding application object: %s" % find_err)
+
+        if not apps: raise RuntimeError("No compilable application found in project '%s'" % project_name)
+        target_app = apps[0]
+        app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (First Found)")()
+        print("WARN: Compiling first found application: %s" % app_name)
+
+    print("DEBUG: Calling build() on app '%s'..." % app_name)
+    if not hasattr(target_app, 'build'):
+         raise TypeError("Selected object '%s' is not an application or doesn't support build()." % app_name)
+
+    # Execute the build
+    target_app.build();
+    print("DEBUG: Build command executed for application '%s'." % app_name)
+
+    # Check messages is harder without direct access to message store from script.
+    # Rely on CODESYS UI or log output for now.
+    print("Compile Initiated For Application: %s" % app_name)
+    print("In Project: %s" % project_name)
+    print("SCRIPT_SUCCESS: Application compilation initiated.")
+    sys.exit(0)
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error initiating compilation for project %s: %s\\n%s" % (PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message)
+    print("SCRIPT_ERROR: %s" % error_message)
+    sys.exit(1)

package/dist/scripts/create_method.py

@@ -0,0 +1,80 @@
+import sys, scriptengine as script_engine, os, traceback
+
+# Import ensure_project_open function from the template
+# This will be prepended by the script loader
+def ensure_project_open(target_project_path):
+    # Function implementation will be included from ensure_project_open.py
+    pass
+
+# Import find_object_by_path function from the template
+# This will be prepended by the script loader
+def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
+    # Function implementation will be included from find_object_by_path.py
+    pass
+
+PARENT_POU_FULL_PATH = "{PARENT_POU_FULL_PATH}" # e.g., "Application/MyFB"
+METHOD_NAME = "{METHOD_NAME}"
+RETURN_TYPE = "{RETURN_TYPE}" # Can be empty string for no return type
+# Optional: Language
+# LANG_GUID_STR = "{LANG_GUID_STR}" # Example if needed
+
+try:
+    print("DEBUG: create_method script: ParentPOU='%s', Name='%s', ReturnType='%s', Project='%s'" % (PARENT_POU_FULL_PATH, METHOD_NAME, RETURN_TYPE, PROJECT_FILE_PATH))
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    if not PARENT_POU_FULL_PATH: raise ValueError("Parent POU full path empty.")
+    if not METHOD_NAME: raise ValueError("Method name empty.")
+    # RETURN_TYPE can be empty
+
+    # Find the parent POU object
+    parent_pou_object = find_object_by_path_robust(primary_project, PARENT_POU_FULL_PATH, "parent POU")
+    if not parent_pou_object: raise ValueError("Parent POU object not found: %s" % PARENT_POU_FULL_PATH)
+
+    parent_pou_name = getattr(parent_pou_object, 'get_name', lambda: PARENT_POU_FULL_PATH)()
+    print("DEBUG: Found Parent POU object: %s" % parent_pou_name)
+
+     # Check if parent object supports creating methods (should implement ScriptIecLanguageMemberContainer)
+    if not hasattr(parent_pou_object, 'create_method'):
+         raise TypeError("Parent object '%s' of type %s does not support create_method." % (parent_pou_name, type(parent_pou_object).__name__))
+
+    # Default language to None (usually ST)
+    lang_guid = None
+    # Use None if RETURN_TYPE is empty string, otherwise use the string
+    actual_return_type = RETURN_TYPE if RETURN_TYPE else None
+    print("DEBUG: Calling create_method: Name='%s', ReturnType=%s, Lang=%s" % (METHOD_NAME, actual_return_type, lang_guid))
+
+    # Call the create_method method ON THE PARENT POU
+    new_method_object = parent_pou_object.create_method(
+        name=METHOD_NAME,
+        return_type=actual_return_type,
+        language=lang_guid # Pass None to use default
+    )
+
+    if new_method_object:
+        new_meth_name = getattr(new_method_object, 'get_name', lambda: METHOD_NAME)()
+        print("DEBUG: Method object created: %s" % new_meth_name)
+
+        # --- SAVE THE PROJECT TO PERSIST THE NEW METHOD OBJECT ---
+        try:
+            print("DEBUG: Saving Project (after method creation)...")
+            primary_project.save()
+            print("DEBUG: Project saved successfully after method creation.")
+        except Exception as save_err:
+            print("ERROR: Failed to save Project after creating method: %s" % save_err)
+            detailed_error = traceback.format_exc()
+            error_message = "Error saving Project after creating method '%s': %s\\n%s" % (METHOD_NAME, save_err, detailed_error)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+        # --- END SAVING ---
+
+        print("Method Created: %s" % new_meth_name)
+        print("Parent POU: %s" % PARENT_POU_FULL_PATH)
+        print("Return Type: %s" % (RETURN_TYPE if RETURN_TYPE else "(None)"))
+        print("SCRIPT_SUCCESS: Method created successfully.")
+        sys.exit(0)
+    else:
+         error_message = "Failed to create method '%s' under '%s'. create_method returned None." % (METHOD_NAME, parent_pou_name)
+         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 method '%s' under POU '%s' in project '%s': %s\\n%s" % (METHOD_NAME, PARENT_POU_FULL_PATH, PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/create_pou.py

@@ -0,0 +1,96 @@
+import sys, scriptengine as script_engine, os, traceback
+
+# Import ensure_project_open function from the template
+# This will be prepended by the script loader
+def ensure_project_open(target_project_path):
+    # Function implementation will be included from ensure_project_open.py
+    pass
+
+# Import find_object_by_path function from the template
+# This will be prepended by the script loader
+def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
+    # Function implementation will be included from find_object_by_path.py
+    pass
+
+POU_NAME = "{POU_NAME}"
+POU_TYPE_STR = "{POU_TYPE_STR}" 
+IMPL_LANGUAGE_STR = "{IMPL_LANGUAGE_STR}"
+PARENT_PATH_REL = "{PARENT_PATH}"
+
+pou_type_map = { 
+    "Program": script_engine.PouType.Program, 
+    "FunctionBlock": script_engine.PouType.FunctionBlock, 
+    "Function": script_engine.PouType.Function 
+}
+# Map common language names to ImplementationLanguages attributes if needed (optional, None usually works)
+# lang_map = { "ST": script_engine.ImplementationLanguage.st, ... }
+
+try:
+    print("DEBUG: create_pou script: Name='%s', Type='%s', Lang='%s', ParentPath='%s', Project='%s'" % (POU_NAME, POU_TYPE_STR, IMPL_LANGUAGE_STR, PARENT_PATH_REL, PROJECT_FILE_PATH))
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    if not POU_NAME: raise ValueError("POU name empty.")
+    if not PARENT_PATH_REL: raise ValueError("Parent path empty.")
+
+    # Resolve POU Type Enum
+    pou_type_enum = pou_type_map.get(POU_TYPE_STR)
+    if not pou_type_enum: raise ValueError("Invalid POU type string: %s. Use Program, FunctionBlock, or Function." % POU_TYPE_STR)
+
+    # Find parent object using the robust function
+    parent_object = find_object_by_path_robust(primary_project, PARENT_PATH_REL, "parent container")
+    if not parent_object: raise ValueError("Parent object not found for path: %s" % PARENT_PATH_REL)
+
+    parent_name = getattr(parent_object, 'get_name', lambda: str(parent_object))()
+    print("DEBUG: Using parent object: %s (Type: %s)" % (parent_name, type(parent_object).__name__))
+
+    # Check if parent object supports creating POUs (should implement ScriptIecLanguageObjectContainer)
+    if not hasattr(parent_object, 'create_pou'):
+        raise TypeError("Parent object '%s' of type %s does not support create_pou." % (parent_name, type(parent_object).__name__))
+
+    # Set language GUID to None (let CODESYS default based on parent/settings)
+    lang_guid = None
+    print("DEBUG: Setting language to None (will use default).")
+    # Example if mapping language string: lang_guid = lang_map.get(IMPL_LANGUAGE_STR, None)
+
+    print("DEBUG: Calling parent_object.create_pou: Name='%s', Type=%s, Lang=%s" % (POU_NAME, pou_type_enum, lang_guid))
+
+    # Call create_pou using keyword arguments
+    new_pou = parent_object.create_pou(
+        name=POU_NAME,
+        type=pou_type_enum,
+        language=lang_guid # Pass None
+    )
+
+    print("DEBUG: parent_object.create_pou returned: %s" % new_pou)
+    if new_pou:
+        new_pou_name = getattr(new_pou, 'get_name', lambda: POU_NAME)()
+        print("DEBUG: POU object created: %s" % new_pou_name)
+
+        # --- SAVE THE PROJECT TO PERSIST THE NEW POU ---
+        try:
+            print("DEBUG: Saving Project...")
+            primary_project.save() # Save the overall project file
+            print("DEBUG: Project saved successfully after POU creation.")
+        except Exception as save_err:
+            print("ERROR: Failed to save Project after POU creation: %s" % save_err)
+            detailed_error = traceback.format_exc()
+            error_message = "Error saving Project after creating POU '%s': %s\\n%s" % (new_pou_name, save_err, detailed_error)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+        # --- END SAVING ---
+
+        print("POU Created: %s" % new_pou_name)
+        print("Type: %s" % POU_TYPE_STR)
+        print("Language: %s (Defaulted)" % IMPL_LANGUAGE_STR)
+        print("Parent Path: %s" % PARENT_PATH_REL)
+        print("SCRIPT_SUCCESS: POU created successfully.")
+        sys.exit(0)
+    else:
+        error_message = "Failed to create POU '%s'. create_pou returned None." % POU_NAME
+        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 POU '%s' in project '%s': %s\\n%s" % (POU_NAME, PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message)
+    print("SCRIPT_ERROR: Error creating POU '%s': %s" % (POU_NAME, e))
+    sys.exit(1)

package/dist/scripts/create_project.py

@@ -0,0 +1,100 @@
+import sys, scriptengine as script_engine, os, shutil, time, traceback
+# Placeholders - These might be Python raw strings (r'path') from the Node.js side
+# So we need to handle them specially
+TEMPLATE_PROJECT_PATH_RAW = '{TEMPLATE_PROJECT_PATH}' # Path to Standard.project 
+PROJECT_FILE_PATH_RAW = '{PROJECT_FILE_PATH}'    # Path for the new project (Target Path)
+
+# Process the paths - if they start with r' and end with ', extract the content
+def extract_path(path_str):
+    if path_str.startswith("r'") and path_str.endswith("'"):
+        # This is a raw string from Node.js - extract the content
+        return path_str[2:-1]
+    return path_str
+
+TEMPLATE_PROJECT_PATH = extract_path(TEMPLATE_PROJECT_PATH_RAW)
+PROJECT_FILE_PATH = extract_path(PROJECT_FILE_PATH_RAW)
+
+print("DEBUG: Processed TEMPLATE_PROJECT_PATH: %s" % TEMPLATE_PROJECT_PATH)
+print("DEBUG: Processed PROJECT_FILE_PATH: %s" % PROJECT_FILE_PATH)
+try:
+    print("DEBUG: Python script create_project (copy from template):")
+    print("DEBUG:   Template Source = %s" % TEMPLATE_PROJECT_PATH)
+    print("DEBUG:   Target Path = %s" % PROJECT_FILE_PATH)
+    if not PROJECT_FILE_PATH: raise ValueError("Target project file path empty.")
+    if not TEMPLATE_PROJECT_PATH: raise ValueError("Template project file path empty.")
+    if not os.path.exists(TEMPLATE_PROJECT_PATH): raise IOError("Template project file not found: %s" % TEMPLATE_PROJECT_PATH)
+
+    # 1. Copy the template project file to the new location
+    target_dir = os.path.dirname(PROJECT_FILE_PATH)
+    print("DEBUG: Target directory path: %s" % target_dir)
+    
+    # More robust directory creation
+    if not os.path.exists(target_dir):
+        try:
+            print("DEBUG: Creating target directory: %s" % target_dir)
+            os.makedirs(target_dir, exist_ok=True)
+            print("DEBUG: Directory creation result - exists after creation: %s" % os.path.exists(target_dir))
+        except Exception as dir_err:
+            print("ERROR: Failed to create directory %s: %s" % (target_dir, dir_err))
+            raise
+    
+    # Check if target file already exists
+    if os.path.exists(PROJECT_FILE_PATH): print("WARN: Target project file already exists, overwriting: %s" % PROJECT_FILE_PATH)
+
+    print("DEBUG: Copying '%s' to '%s'..." % (TEMPLATE_PROJECT_PATH, PROJECT_FILE_PATH))
+    try:
+        # Complete path diagnosis
+        print("DEBUG: Template path absolute: %s" % os.path.abspath(TEMPLATE_PROJECT_PATH))
+        print("DEBUG: Target path absolute: %s" % os.path.abspath(PROJECT_FILE_PATH))
+        print("DEBUG: Template exists: %s" % os.path.exists(TEMPLATE_PROJECT_PATH))
+        print("DEBUG: Target dir exists: %s" % os.path.exists(target_dir))
+        print("DEBUG: Target dir is writable: %s" % os.access(target_dir, os.W_OK))
+        
+        # Perform the copy
+        shutil.copy2(TEMPLATE_PROJECT_PATH, PROJECT_FILE_PATH) # copy2 preserves metadata
+        
+        # Verify copy succeeded
+        if os.path.exists(PROJECT_FILE_PATH):
+            print("DEBUG: File copy VERIFIED - file exists at destination")
+            print("DEBUG: File size at destination: %s bytes" % os.path.getsize(PROJECT_FILE_PATH))
+        else:
+            print("ERROR: Copy seemed to succeed but file does not exist at destination!")
+            raise IOError("File not found at destination after copy: %s" % PROJECT_FILE_PATH)
+    except Exception as copy_err:
+        print("ERROR: Failed to copy file: %s" % copy_err)
+        raise
+        
+    print("DEBUG: File copy complete.")
+
+    # 2. Open the newly copied project file
+    print("DEBUG: Opening the copied project: %s" % PROJECT_FILE_PATH)
+    # Set flags for silent opening
+    update_mode = script_engine.VersionUpdateFlags.NoUpdates | script_engine.VersionUpdateFlags.SilentMode
+    # try:
+    #     update_mode = script_engine.VersionUpdateFlags.NoUpdates | script_engine.VersionUpdateFlags.SilentMode
+    # except AttributeError:
+    #     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.")
+        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)
+    print(error_message); print("SCRIPT_ERROR: Error copying/opening template: %s" % e); sys.exit(1)