@codesys/mcp-toolkit 1.5.2 → 1.5.5

package/.claude/settings.local.json

@@ -20,7 +20,9 @@
       "Bash(ls:*)",
       "Bash(ls:*)",
       "Bash(mkdir:*)",
-      "Bash(mkdir:*)"
+      "Bash(mkdir:*)",
+      "Bash(node:*)",
+      "Bash(node:*)"
     ],
     "deny": []
   }

package/CHANGELOG.md

@@ -5,6 +5,25 @@ 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.5.5] - 2025-05-02
+### Fixed
+- Added enhanced command.json file verification to debug session communication
+- Improved logging for command file operations to diagnose IPC issues
+- Added command data verification to detect potential file corruption
+
+## [1.5.4] - 2025-05-02
+### Fixed
+- Added `--no-session` flag to disable session management when CODESYS UI hangs
+- Improved session handling with better error detection and user feedback
+- Removed hardcoded session disable flag in favor of command-line option
+- Added safeguards to prevent UI blocking during session operations
+
+## [1.5.3] - 2025-05-02
+### Fixed
+- Added automatic session startup when server starts
+- Improved session detection with better diagnostics
+- Enhanced logging for session command status
+
 ## [1.5.2] - 2025-05-02
 ### Fixed
 - Re-enabled session management feature that was disabled for debugging

package/dist/bin.js

@@ -38,6 +38,8 @@ commander_1.program
     // Add workspace option if needed, defaults to cwd
     .option('-w, --workspace <dir>', 'Workspace directory for relative project paths', process.cwd() // Default to current working directory
 )
+    // Add option to disable session management
+    .option('--no-session', 'Disable session management (use one-time script execution only)', false)
     .parse(process.argv); // Parse the arguments
 const options = commander_1.program.opts();
 // --- Log the options Commander parsed ---
@@ -54,8 +56,10 @@ console.error(`========================================`);
 const serverConfig = {
     codesysPath: options.codesysPath.trim(),
     profileName: options.codesysProfile.trim(),
-    workspaceDir: options.workspace.trim() // Pass workspace dir
+    workspaceDir: options.workspace.trim(), // Pass workspace dir
+    enableSessionManagement: options.session // Determined by --no-session flag (default: true)
 };
+console.error(`BIN.TS: Session management is ${serverConfig.enableSessionManagement ? 'enabled' : 'disabled'}`);
 // --- End Prepare Config ---
 // --- Call the server setup function ---
 console.error("BIN.TS: Calling startMcpServer...");

package/dist/check_session_paths.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Session Path Diagnostic Tool
+ * This script checks the consistency of paths used in the session management system.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+// Session directory paths from direct_session_command.ts
+const DIRECT_SESSION_DIR = path.join(os.tmpdir(), 'codesys_session');
+const DIRECT_COMMAND_FILE = path.join(DIRECT_SESSION_DIR, 'command.json');
+const DIRECT_RESULT_FILE = path.join(DIRECT_SESSION_DIR, 'result.json');
+const DIRECT_SESSION_LOCK_FILE = path.join(DIRECT_SESSION_DIR, 'session.lock');
+const DIRECT_STATE_FILE = path.join(DIRECT_SESSION_DIR, 'session_state.json');
+// Constants from sessionManager.ts
+const SESSION_DIR = path.join(os.tmpdir(), 'codesys_session');
+const COMMAND_FILE = 'command.json';
+const RESULT_FILE = 'result.json';
+const STATE_FILE = 'session_state.json';
+const SESSION_LOCK_FILE = 'session.lock';
+console.log("==== Session Path Diagnostics ====");
+console.log("\nBase session directory check:");
+console.log(`- DIRECT_SESSION_DIR: ${DIRECT_SESSION_DIR}`);
+console.log(`- SESSION_DIR: ${SESSION_DIR}`);
+console.log(`  Direct and manager directories match: ${DIRECT_SESSION_DIR === SESSION_DIR}`);
+console.log("\nExpected file paths in direct_session_command.ts:");
+console.log(`- Command file: ${DIRECT_COMMAND_FILE}`);
+console.log(`- Result file: ${DIRECT_RESULT_FILE}`);
+console.log(`- Lock file: ${DIRECT_SESSION_LOCK_FILE}`);
+console.log(`- State file: ${DIRECT_STATE_FILE}`);
+console.log("\nFile names in sessionManager.ts:");
+console.log(`- Command file: ${COMMAND_FILE}`);
+console.log(`- Result file: ${RESULT_FILE}`);
+console.log(`- Lock file: ${SESSION_LOCK_FILE}`);
+console.log(`- State file: ${STATE_FILE}`);
+console.log("\nFile existence checks:");
+console.log(`- Base session directory exists: ${fs.existsSync(SESSION_DIR)}`);
+if (fs.existsSync(SESSION_DIR)) {
+    console.log(`- Command file exists: ${fs.existsSync(DIRECT_COMMAND_FILE)}`);
+    console.log(`- Result file exists: ${fs.existsSync(DIRECT_RESULT_FILE)}`);
+    console.log(`- Lock file exists: ${fs.existsSync(DIRECT_SESSION_LOCK_FILE)}`);
+    console.log(`- State file exists: ${fs.existsSync(DIRECT_STATE_FILE)}`);
+    console.log("\nContent checks (if files exist):");
+    if (fs.existsSync(DIRECT_COMMAND_FILE)) {
+        try {
+            const commandContent = fs.readFileSync(DIRECT_COMMAND_FILE, 'utf8');
+            console.log(`- Command file content: ${commandContent.substring(0, 150)}...`);
+            try {
+                const commandJson = JSON.parse(commandContent);
+                console.log(`  Status: ${commandJson.status}`);
+                console.log(`  Has command object: ${commandJson.command !== null}`);
+                if (commandJson.command) {
+                    console.log(`  Command type: ${commandJson.command.type}`);
+                }
+            }
+            catch (e) {
+                console.log(`  Error parsing command file JSON: ${e}`);
+            }
+        }
+        catch (e) {
+            console.log(`- Error reading command file: ${e}`);
+        }
+    }
+    if (fs.existsSync(DIRECT_RESULT_FILE)) {
+        try {
+            const resultContent = fs.readFileSync(DIRECT_RESULT_FILE, 'utf8');
+            console.log(`- Result file content: ${resultContent.substring(0, 150)}...`);
+            try {
+                const resultJson = JSON.parse(resultContent);
+                console.log(`  Status: ${resultJson.status}`);
+                console.log(`  Has result object: ${resultJson.result !== null}`);
+            }
+            catch (e) {
+                console.log(`  Error parsing result file JSON: ${e}`);
+            }
+        }
+        catch (e) {
+            console.log(`- Error reading result file: ${e}`);
+        }
+    }
+    if (fs.existsSync(DIRECT_SESSION_LOCK_FILE)) {
+        try {
+            const lockContent = fs.readFileSync(DIRECT_SESSION_LOCK_FILE, 'utf8');
+            console.log(`- Lock file content: ${lockContent}`);
+            const lockTime = parseFloat(lockContent);
+            const currentTime = Date.now() / 1000; // convert to seconds
+            const lockAgeSeconds = currentTime - lockTime;
+            console.log(`  Lock age: ${lockAgeSeconds.toFixed(1)} seconds`);
+        }
+        catch (e) {
+            console.log(`- Error reading lock file: ${e}`);
+        }
+    }
+    if (fs.existsSync(DIRECT_STATE_FILE)) {
+        try {
+            const stateContent = fs.readFileSync(DIRECT_STATE_FILE, 'utf8');
+            console.log(`- State file content: ${stateContent.substring(0, 150)}...`);
+            try {
+                const stateJson = JSON.parse(stateContent);
+                console.log(`  Session ID: ${stateJson.sessionId || stateJson.session_id}`);
+                console.log(`  Status: ${stateJson.status}`);
+            }
+            catch (e) {
+                console.log(`  Error parsing state file JSON: ${e}`);
+            }
+        }
+        catch (e) {
+            console.log(`- Error reading state file: ${e}`);
+        }
+    }
+}
+else {
+    console.log("  Cannot check files as base directory does not exist");
+}
+console.log("\n==== End of Session Path Diagnostics ====");

package/dist/codesys_interop.js

@@ -91,10 +91,10 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
         if (!fs.existsSync(codesysExePath))
             throw new Error(`CODESYS executable not found at provided path: ${codesysExePath}`);
         // --- End Pre-checks ---
-        // Session management feature control
-        const SESSION_FEATURE_DISABLED = false; // Session feature enabled
+        // Session management feature is now fully controlled by the presence of sessionManager
+        // No need for a separate flag as server.ts will set sessionManager to undefined if disabled
         // --- Check if we should use the persistent session ---
-        if (!SESSION_FEATURE_DISABLED && sessionManager) {
+        if (sessionManager) {
             const sessionState = sessionManager.getState();
             // Check if the session is active
             if (sessionState === sessionManager_1.SessionState.RUNNING || sessionState === sessionManager_1.SessionState.BUSY) {
@@ -141,9 +141,6 @@ function executeCodesysScript(scriptContent, codesysExePath, codesysProfileName,
                 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`);
         }

package/dist/direct_session_command.js

@@ -69,19 +69,24 @@ const STATE_FILE = path.join(SESSION_DIR, 'session_state.json');
  */
 function isSessionActive() {
     try {
+        // Log the paths we're checking to help with debugging
+        console.error(`DIRECT_SESSION: Checking for active session...`);
+        console.error(`DIRECT_SESSION: SESSION_DIR: ${SESSION_DIR}`);
+        console.error(`DIRECT_SESSION: SESSION_LOCK_FILE: ${SESSION_LOCK_FILE}`);
+        console.error(`DIRECT_SESSION: COMMAND_FILE: ${COMMAND_FILE}`);
         // Check if session directory exists
         if (!fs.existsSync(SESSION_DIR)) {
-            console.error(`SESSION_DIR doesn't exist: ${SESSION_DIR}`);
+            console.error(`DIRECT_SESSION: SESSION_DIR doesn't exist: ${SESSION_DIR}`);
             return false;
         }
         // Check if lock file exists
         if (!fs.existsSync(SESSION_LOCK_FILE)) {
-            console.error(`SESSION_LOCK_FILE doesn't exist: ${SESSION_LOCK_FILE}`);
+            console.error(`DIRECT_SESSION: SESSION_LOCK_FILE doesn't exist: ${SESSION_LOCK_FILE}`);
             return false;
         }
         // Check if command file exists
         if (!fs.existsSync(COMMAND_FILE)) {
-            console.error(`COMMAND_FILE doesn't exist: ${COMMAND_FILE}`);
+            console.error(`DIRECT_SESSION: COMMAND_FILE doesn't exist: ${COMMAND_FILE}`);
             return false;
         }
         // Read the lock file to check age
@@ -89,15 +94,27 @@ function isSessionActive() {
         const lockTime = parseFloat(lockFileContent);
         const currentTime = Date.now() / 1000; // convert to seconds
         const lockAgeSeconds = currentTime - lockTime;
+        console.error(`DIRECT_SESSION: Lock file age: ${lockAgeSeconds.toFixed(1)} seconds`);
         // If lock is too old, session might be dead
         if (lockAgeSeconds > 30) {
-            console.error(`Session lock file is too old (${lockAgeSeconds.toFixed(1)} seconds)`);
+            console.error(`DIRECT_SESSION: Session lock file is too old (${lockAgeSeconds.toFixed(1)} seconds)`);
             return false;
         }
+        // Try to read the command file to verify it's in the expected format
+        try {
+            const commandContent = fs.readFileSync(COMMAND_FILE, 'utf8');
+            const commandData = JSON.parse(commandContent);
+            console.error(`DIRECT_SESSION: Command file status: ${commandData.status}`);
+        }
+        catch (cmdError) {
+            console.error(`DIRECT_SESSION: Error parsing command file: ${cmdError}`);
+            return false;
+        }
+        console.error(`DIRECT_SESSION: Session appears to be active`);
         return true;
     }
     catch (error) {
-        console.error(`Error checking session: ${error}`);
+        console.error(`DIRECT_SESSION: Error checking session: ${error}`);
         return false;
     }
 }
@@ -126,9 +143,24 @@ function executeScriptDirect(scriptContent_1) {
             timestamp: Date.now()
         };
         console.error(`DIRECT_SESSION: Writing command to ${COMMAND_FILE}`);
-        // Write command to file
-        fs.writeFileSync(COMMAND_FILE, JSON.stringify(commandData, null, 2));
-        console.error(`DIRECT_SESSION: Command written to file`);
+        console.error(`DIRECT_SESSION: Command data: ${JSON.stringify(commandData)}`);
+        try {
+            // Write command to file
+            fs.writeFileSync(COMMAND_FILE, JSON.stringify(commandData, null, 2));
+            console.error(`DIRECT_SESSION: Command written to file`);
+            // Verify the file was written correctly
+            try {
+                const verifyContent = fs.readFileSync(COMMAND_FILE, 'utf8');
+                console.error(`DIRECT_SESSION: Verification - Command file now contains: ${verifyContent.substring(0, 100)}...`);
+            }
+            catch (verifyErr) {
+                console.error(`DIRECT_SESSION: Verification failed - could not read command file: ${verifyErr}`);
+            }
+        }
+        catch (writeErr) {
+            console.error(`DIRECT_SESSION: ERROR writing command file: ${writeErr}`);
+            throw writeErr; // Re-throw to propagate the error
+        }
         // Poll for result
         return new Promise((resolve, reject) => {
             let pollCount = 0;

package/dist/server.js

@@ -117,8 +117,39 @@ function startMcpServer(config) {
         }
         // --- End Helper Function ---
         // --- Initialize Session Manager ---
-        const sessionManager = new sessionManager_1.CodesysSessionManager(codesysExePath, codesysProfileName);
-        console.error('SERVER.TS: Session manager initialized');
+        // Default to true if not specified
+        const enableSessionManagement = config.enableSessionManagement !== false;
+        console.error(`SERVER.TS: Session management is ${enableSessionManagement ? 'enabled' : 'disabled'}`);
+        // Create session manager instance
+        let sessionManager;
+        if (enableSessionManagement) {
+            sessionManager = new sessionManager_1.CodesysSessionManager(codesysExePath, codesysProfileName);
+            console.error('SERVER.TS: Session manager initialized');
+            // Only start a session if explicitly enabled
+            try {
+                // Check if session is already active
+                console.error('SERVER.TS: Checking if session is already active...');
+                const isActive = (0, direct_session_command_1.isSessionActive)();
+                if (isActive) {
+                    console.error('SERVER.TS: Session is already active');
+                }
+                else {
+                    console.error('SERVER.TS: Session not active, starting new session...');
+                    console.error('SERVER.TS: IMPORTANT: If CODESYS hangs during session startup, use --no-session flag');
+                    yield sessionManager.startSession();
+                    console.error('SERVER.TS: Session start initiated');
+                }
+            }
+            catch (error) {
+                console.error(`SERVER.TS: Error starting session: ${error.message}`);
+                console.error('SERVER.TS: Will fallback to one-time execution for operations');
+                // Continue without session, will fallback to one-time execution
+            }
+        }
+        else {
+            console.error('SERVER.TS: Session management is disabled, will use one-time script execution');
+            sessionManager = undefined;
+        }
         // --- End Session Manager Initialization ---
         // --- Preload script templates ---
         try {

package/dist/sessionManager.js

@@ -639,8 +639,24 @@ class CodesysSessionManager extends events_1.EventEmitter {
                     };
                     // Send the command by writing to the command file
                     console.error(`SESSION_MANAGER: Writing command to file ${this.commandFilePath}`);
-                    fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData, null, 2));
-                    console.error(`SESSION_MANAGER: Command written to file`);
+                    console.error(`SESSION_MANAGER: Command data: ${JSON.stringify(commandData)}`);
+                    try {
+                        // Write command to file
+                        fs.writeFileSync(this.commandFilePath, JSON.stringify(commandData, null, 2));
+                        console.error(`SESSION_MANAGER: Command written to file`);
+                        // Verify the file was written correctly
+                        try {
+                            const verifyContent = fs.readFileSync(this.commandFilePath, 'utf8');
+                            console.error(`SESSION_MANAGER: Verification - Command file now contains: ${verifyContent.substring(0, 100)}...`);
+                        }
+                        catch (verifyErr) {
+                            console.error(`SESSION_MANAGER: Verification failed - could not read command file: ${verifyErr}`);
+                        }
+                    }
+                    catch (writeErr) {
+                        console.error(`SESSION_MANAGER: ERROR writing command file: ${writeErr}`);
+                        throw writeErr; // Re-throw to propagate the error
+                    }
                     // Start reading the result file
                     this.readResultFile(scriptId);
                 }

package/package.json

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