@codesys/mcp-toolkit 1.2.1 → 1.3.0

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

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/create_project.py

@@ -1,7 +1,21 @@
 import sys, scriptengine as script_engine, os, shutil, time, traceback
-# Placeholders
-TEMPLATE_PROJECT_PATH = r'{TEMPLATE_PROJECT_PATH}' # Path to Standard.project
-PROJECT_FILE_PATH = r'{PROJECT_FILE_PATH}'    # Path for the new project (Target Path)
+# 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)
@@ -12,12 +26,44 @@ try:
 
     # 1. Copy the template project file to the new location
     target_dir = os.path.dirname(PROJECT_FILE_PATH)
-    if not os.path.exists(target_dir): print("DEBUG: Creating target directory: %s" % target_dir); os.makedirs(target_dir)
+    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))
-    shutil.copy2(TEMPLATE_PROJECT_PATH, PROJECT_FILE_PATH) # copy2 preserves metadata
+    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

package/dist/scripts/session_status.py

@@ -0,0 +1,132 @@
+import sys, os, json, time
+import tempfile
+
+# Define markers for script results
+SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
+SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
+
+# Session state and command files
+SESSION_DIR = os.path.join(tempfile.gettempdir(), "codesys_session")
+SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
+COMMAND_FILE = os.path.join(SESSION_DIR, "command.json")
+RESULT_FILE = os.path.join(SESSION_DIR, "result.json")
+SESSION_LOCK_FILE = os.path.join(SESSION_DIR, "session.lock")
+
+def check_session_status():
+    """Check the status of a CODESYS session"""
+    try:
+        # Check if session directory exists
+        if not os.path.exists(SESSION_DIR):
+            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session directory not found.")
+            return False
+
+        # Check if session state file exists
+        if not os.path.exists(SESSION_STATE_FILE):
+            print(f"{SCRIPT_SUCCESS_MARKER}: No session active. Session state file not found.")
+            return False
+
+        # Read session state
+        with open(SESSION_STATE_FILE, 'r') as f:
+            try:
+                session_state = json.load(f)
+            except json.JSONDecodeError:
+                print(f"{SCRIPT_ERROR_MARKER}: Invalid session state file")
+                return False
+
+        # Check if session is active
+        active = session_state.get('active', False)
+        status = session_state.get('status', 'unknown')
+        
+        # Check session lock file to see if it's been updated recently
+        if os.path.exists(SESSION_LOCK_FILE):
+            try:
+                with open(SESSION_LOCK_FILE, 'r') as f:
+                    lock_time = float(f.read().strip())
+                    current_time = time.time()
+                    time_diff = current_time - lock_time
+                    
+                    # If lock file hasn't been updated in 30 seconds, session might be dead
+                    if time_diff > 30:
+                        print(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be inactive (lock file stale by {time_diff:.1f} seconds)")
+                        # But we'll leave the active flag as is, since it might just be busy
+            except Exception as e:
+                print(f"Error reading lock file: {e}")
+        
+        # Execute a ping test by sending a simple command
+        if active and status in ["running", "busy"]:
+            # Try to ping the session
+            try:
+                # Check if command file exists
+                if os.path.exists(COMMAND_FILE):
+                    # Create ping command
+                    ping_command = {
+                        "id": f"ping_{int(time.time())}",
+                        "type": "execute_script",
+                        "script": "print('SCRIPT_SUCCESS: Ping successful')",
+                        "timestamp": time.time()
+                    }
+                    
+                    # Write command to file
+                    command_data = {
+                        "status": "pending",
+                        "command": ping_command,
+                        "timestamp": time.time()
+                    }
+                    
+                    with open(COMMAND_FILE, 'w') as f:
+                        json.dump(command_data, f)
+                    
+                    # Wait for result (with short timeout)
+                    timeout = 5  # seconds
+                    start_time = time.time()
+                    ping_success = False
+                    
+                    while not ping_success and (time.time() - start_time) < timeout:
+                        # Check if result file exists
+                        if not os.path.exists(RESULT_FILE):
+                            time.sleep(0.5)
+                            continue
+                        
+                        try:
+                            with open(RESULT_FILE, 'r') as f:
+                                result_data = json.load(f)
+                                
+                                if result_data.get("status") == "complete" and result_data.get("result"):
+                                    result = result_data.get("result")
+                                    if result.get('id') == ping_command['id'] and result.get('success', False):
+                                        ping_success = True
+                                        break
+                        except Exception as e:
+                            print(f"Error reading result: {e}")
+                            time.sleep(0.5)
+                    
+                    if not ping_success:
+                        print(f"{SCRIPT_SUCCESS_MARKER}: Session appears to be unresponsive to ping")
+                        return False
+            except Exception as e:
+                print(f"Error during ping test: {e}")
+        
+        # Build status message
+        project_info = ""
+        if session_state.get('project_open', False):
+            project_name = session_state.get('project_name', 'Unknown')
+            project_path = session_state.get('project_path', 'Unknown')
+            project_info = f", Project: {project_name} ({project_path})"
+        
+        if active and status in ["running", "busy"]:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is active (Status: {status}{project_info})")
+            return True
+        else:
+            print(f"{SCRIPT_SUCCESS_MARKER}: Session is not active (Status: {status})")
+            return False
+
+    except Exception as e:
+        print(f"{SCRIPT_ERROR_MARKER}: Error checking session status - {str(e)}")
+        return False
+
+# Main script
+if __name__ == "__main__":
+    if check_session_status():
+        sys.exit(0)
+    else:
+        sys.exit(1)