@codesys/mcp-toolkit 1.2.1 → 1.2.4

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,168 @@
+import sys, os, json, time, tempfile
+
+# Define markers for script results
+SCRIPT_SUCCESS_MARKER = "SCRIPT_SUCCESS"
+SCRIPT_ERROR_MARKER = "SCRIPT_ERROR"
+
+# Session state file and pipes
+SESSION_DIR = os.path.join(tempfile.gettempdir(), "codesys_session")
+SESSION_STATE_FILE = os.path.join(SESSION_DIR, "session_state.json")
+COMMAND_PIPE = os.path.join(SESSION_DIR, "command_pipe")
+RESULT_PIPE = os.path.join(SESSION_DIR, "result_pipe")
+
+def check_session_status():
+    """Check the status of a CODESYS session by reading the state file"""
+    try:
+        # Check if session directory exists
+        if not os.path.exists(SESSION_DIR):
+            return {
+                "session_exists": False,
+                "active": False,
+                "message": "No session directory found"
+            }
+            
+        # Check if state file exists
+        if not os.path.exists(SESSION_STATE_FILE):
+            return {
+                "session_exists": True,
+                "active": False,
+                "message": "Session directory exists but no state file found"
+            }
+            
+        # Read the state file
+        with open(SESSION_STATE_FILE, 'r') as f:
+            session_state = json.load(f)
+            
+        # Check if pipes exist
+        pipes_exist = os.path.exists(COMMAND_PIPE) and os.path.exists(RESULT_PIPE)
+        
+        # Get session duration if available
+        start_time = session_state.get("start_time", 0)
+        if start_time > 0:
+            current_time = time.time()
+            duration_secs = int(current_time - start_time)
+            hours, remainder = divmod(duration_secs, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            duration = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+        else:
+            duration = "unknown"
+            
+        # Last update time
+        last_update = session_state.get("last_update", 0)
+        last_update_str = "never"
+        if last_update > 0:
+            seconds_since_update = int(time.time() - last_update)
+            if seconds_since_update < 60:
+                last_update_str = f"{seconds_since_update} seconds ago"
+            elif seconds_since_update < 3600:
+                last_update_str = f"{seconds_since_update // 60} minutes ago"
+            else:
+                last_update_str = f"{seconds_since_update // 3600} hours ago"
+                
+        return {
+            "session_exists": True,
+            "active": session_state.get("active", False),
+            "project_open": session_state.get("project_open", False),
+            "project_name": session_state.get("project_name", "unknown"),
+            "project_path": session_state.get("project_path", "unknown"),
+            "duration": duration,
+            "pipes_exist": pipes_exist,
+            "last_update": last_update_str,
+            "message": "Session information retrieved successfully"
+        }
+    except Exception as e:
+        return {
+            "session_exists": True,
+            "active": False,
+            "error": str(e),
+            "message": f"Error reading session state: {e}"
+        }
+
+def ping_session():
+    """Attempt to ping the session with a simple command to verify it's responsive"""
+    try:
+        if not os.path.exists(COMMAND_PIPE) or not os.path.exists(RESULT_PIPE):
+            return False
+            
+        ping_command = {
+            "id": f"ping_{time.time()}",
+            "type": "execute_script",
+            "script": "print('SCRIPT_SUCCESS: Ping successful')"
+        }
+        
+        # Set a timeout for the ping operation
+        timeout = 5  # seconds
+        
+        # Use non-blocking I/O to handle timeouts
+        import select
+        
+        # Send the ping command
+        with open(COMMAND_PIPE, 'w') as cmd_pipe:
+            cmd_pipe.write(json.dumps(ping_command))
+        
+        # Wait for the result pipe to be readable with timeout
+        res_fd = os.open(RESULT_PIPE, os.O_RDONLY | os.O_NONBLOCK)
+        ready, _, _ = select.select([res_fd], [], [], timeout)
+        
+        if not ready:
+            os.close(res_fd)
+            return False
+            
+        # Read the result
+        result_json = os.read(res_fd, 4096).decode('utf-8').strip()
+        os.close(res_fd)
+        
+        if result_json:
+            try:
+                result = json.loads(result_json)
+                return result.get("success", False)
+            except json.JSONDecodeError:
+                return False
+        else:
+            return False
+            
+    except Exception as e:
+        print(f"Error pinging session: {e}")
+        return False
+
+def main():
+    try:
+        # Get session status
+        status = check_session_status()
+        
+        # Print status information
+        print(f"Session Exists: {status.get('session_exists', False)}")
+        print(f"Session Active: {status.get('active', False)}")
+        
+        # If session exists, print more details
+        if status.get("session_exists", False):
+            if status.get("active", False):
+                # Try to ping the session
+                is_responsive = ping_session()
+                print(f"Session Responsive: {is_responsive}")
+                
+                # Print project information if available
+                if "project_open" in status:
+                    print(f"Project Open: {status['project_open']}")
+                if "project_name" in status:
+                    print(f"Project Name: {status['project_name']}")
+                if "project_path" in status:
+                    print(f"Project Path: {status['project_path']}")
+                if "duration" in status:
+                    print(f"Session Duration: {status['duration']}")
+                if "last_update" in status:
+                    print(f"Last Activity: {status['last_update']}")
+            else:
+                print("Session is not active (stopped or crashed)")
+                
+        # Print the final result marker
+        print(f"{SCRIPT_SUCCESS_MARKER}: Session status check complete")
+        sys.exit(0)
+        
+    except Exception as e:
+        print(f"Error checking session status: {e}")
+        print(f"{SCRIPT_ERROR_MARKER}: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()